﻿using System;
using System.ComponentModel;
using System.Drawing;
using System.IO;
using System.Runtime.Serialization;

namespace HalconDotNet
{
	/// <summary>Represents an instance of a region object(-array).</summary>
	// Token: 0x0200005B RID: 91
	[Serializable]
	public class HRegion : HObject, ISerializable, ICloneable
	{
		/// <summary>Create an uninitialized iconic object</summary>
		// Token: 0x06001595 RID: 5525 RVA: 0x00026126 File Offset: 0x00024326
		public HRegion() : base(HObjectBase.UNDEF, false)
		{
		}

		// Token: 0x06001596 RID: 5526 RVA: 0x0008B1E6 File Offset: 0x000893E6
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HRegion(IntPtr key) : this(key, true)
		{
			this.AssertObjectClass();
			GC.KeepAlive(this);
		}

		// Token: 0x06001597 RID: 5527 RVA: 0x0008B1FC File Offset: 0x000893FC
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HRegion(IntPtr key, bool copy) : base(key, copy)
		{
			this.AssertObjectClass();
			GC.KeepAlive(this);
		}

		// Token: 0x06001598 RID: 5528 RVA: 0x0008B212 File Offset: 0x00089412
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HRegion(HObject obj) : base(obj)
		{
			this.AssertObjectClass();
			GC.KeepAlive(this);
		}

		// Token: 0x06001599 RID: 5529 RVA: 0x0008B227 File Offset: 0x00089427
		private void AssertObjectClass()
		{
			HalconAPI.AssertObjectClass(this.key, "region");
		}

		/// <summary>Returns the iconic object(s) at the specified index</summary>
		// Token: 0x1700004F RID: 79
		public HRegion this[HTuple index]
		{
			get
			{
				return this.SelectObj(index);
			}
		}

		// Token: 0x0600159B RID: 5531 RVA: 0x0008B242 File Offset: 0x00089442
		[EditorBrowsable(EditorBrowsableState.Never)]
		public static int LoadNew(IntPtr proc, int parIndex, int err, out HRegion obj)
		{
			obj = new HRegion(HObjectBase.UNDEF);
			return obj.Load(proc, parIndex, err);
		}

		/// <summary>
		///   Create a rectangle parallel to the coordinate axes.
		///   Modified instance represents: Created rectangle.
		/// </summary>
		/// <param name="row1">Line of upper left corner point. Default: 30.0</param>
		/// <param name="column1">Column of upper left corner point. Default: 20.0</param>
		/// <param name="row2">Line of lower right corner point. Default: 100.0</param>
		/// <param name="column2">Column of lower right corner point. Default: 200.0</param>
		// Token: 0x0600159C RID: 5532 RVA: 0x0008B25C File Offset: 0x0008945C
		public HRegion(HTuple row1, HTuple column1, HTuple row2, HTuple column2)
		{
			IntPtr proc = HalconAPI.PreCall(603);
			HalconAPI.Store(proc, 0, row1);
			HalconAPI.Store(proc, 1, column1);
			HalconAPI.Store(proc, 2, row2);
			HalconAPI.Store(proc, 3, column2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row1);
			HalconAPI.UnpinTuple(column1);
			HalconAPI.UnpinTuple(row2);
			HalconAPI.UnpinTuple(column2);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create a rectangle parallel to the coordinate axes.
		///   Modified instance represents: Created rectangle.
		/// </summary>
		/// <param name="row1">Line of upper left corner point. Default: 30.0</param>
		/// <param name="column1">Column of upper left corner point. Default: 20.0</param>
		/// <param name="row2">Line of lower right corner point. Default: 100.0</param>
		/// <param name="column2">Column of lower right corner point. Default: 200.0</param>
		// Token: 0x0600159D RID: 5533 RVA: 0x0008B2DC File Offset: 0x000894DC
		public HRegion(double row1, double column1, double row2, double column2)
		{
			IntPtr proc = HalconAPI.PreCall(603);
			HalconAPI.StoreD(proc, 0, row1);
			HalconAPI.StoreD(proc, 1, column1);
			HalconAPI.StoreD(proc, 2, row2);
			HalconAPI.StoreD(proc, 3, column2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create an ellipse sector.
		///   Modified instance represents: Created ellipse(s).
		/// </summary>
		/// <param name="row">Line index of center. Default: 200.0</param>
		/// <param name="column">Column index of center. Default: 200.0</param>
		/// <param name="phi">Orientation of the longer radius (Radius1). Default: 0.0</param>
		/// <param name="radius1">Longer radius. Default: 100.0</param>
		/// <param name="radius2">Shorter radius. Default: 60.0</param>
		/// <param name="startAngle">Start angle of the sector. Default: 0.0</param>
		/// <param name="endAngle">End angle of the sector. Default: 3.14159</param>
		// Token: 0x0600159E RID: 5534 RVA: 0x0008B344 File Offset: 0x00089544
		public HRegion(HTuple row, HTuple column, HTuple phi, HTuple radius1, HTuple radius2, HTuple startAngle, HTuple endAngle)
		{
			IntPtr proc = HalconAPI.PreCall(608);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, column);
			HalconAPI.Store(proc, 2, phi);
			HalconAPI.Store(proc, 3, radius1);
			HalconAPI.Store(proc, 4, radius2);
			HalconAPI.Store(proc, 5, startAngle);
			HalconAPI.Store(proc, 6, endAngle);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HalconAPI.UnpinTuple(phi);
			HalconAPI.UnpinTuple(radius1);
			HalconAPI.UnpinTuple(radius2);
			HalconAPI.UnpinTuple(startAngle);
			HalconAPI.UnpinTuple(endAngle);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create an ellipse sector.
		///   Modified instance represents: Created ellipse(s).
		/// </summary>
		/// <param name="row">Line index of center. Default: 200.0</param>
		/// <param name="column">Column index of center. Default: 200.0</param>
		/// <param name="phi">Orientation of the longer radius (Radius1). Default: 0.0</param>
		/// <param name="radius1">Longer radius. Default: 100.0</param>
		/// <param name="radius2">Shorter radius. Default: 60.0</param>
		/// <param name="startAngle">Start angle of the sector. Default: 0.0</param>
		/// <param name="endAngle">End angle of the sector. Default: 3.14159</param>
		// Token: 0x0600159F RID: 5535 RVA: 0x0008B3F4 File Offset: 0x000895F4
		public HRegion(double row, double column, double phi, double radius1, double radius2, double startAngle, double endAngle)
		{
			IntPtr proc = HalconAPI.PreCall(608);
			HalconAPI.StoreD(proc, 0, row);
			HalconAPI.StoreD(proc, 1, column);
			HalconAPI.StoreD(proc, 2, phi);
			HalconAPI.StoreD(proc, 3, radius1);
			HalconAPI.StoreD(proc, 4, radius2);
			HalconAPI.StoreD(proc, 5, startAngle);
			HalconAPI.StoreD(proc, 6, endAngle);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create a circle sector.
		///   Modified instance represents: Generated circle sector.
		/// </summary>
		/// <param name="row">Line index of center. Default: 200.0</param>
		/// <param name="column">Column index of center. Default: 200.0</param>
		/// <param name="radius">Radius of circle. Default: 100.5</param>
		/// <param name="startAngle">Start angle of the circle sector. Default: 0.0</param>
		/// <param name="endAngle">End angle of the circle sector. Default: 3.14159</param>
		// Token: 0x060015A0 RID: 5536 RVA: 0x0008B474 File Offset: 0x00089674
		public HRegion(HTuple row, HTuple column, HTuple radius, HTuple startAngle, HTuple endAngle)
		{
			IntPtr proc = HalconAPI.PreCall(610);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, column);
			HalconAPI.Store(proc, 2, radius);
			HalconAPI.Store(proc, 3, startAngle);
			HalconAPI.Store(proc, 4, endAngle);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HalconAPI.UnpinTuple(radius);
			HalconAPI.UnpinTuple(startAngle);
			HalconAPI.UnpinTuple(endAngle);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create a circle sector.
		///   Modified instance represents: Generated circle sector.
		/// </summary>
		/// <param name="row">Line index of center. Default: 200.0</param>
		/// <param name="column">Column index of center. Default: 200.0</param>
		/// <param name="radius">Radius of circle. Default: 100.5</param>
		/// <param name="startAngle">Start angle of the circle sector. Default: 0.0</param>
		/// <param name="endAngle">End angle of the circle sector. Default: 3.14159</param>
		// Token: 0x060015A1 RID: 5537 RVA: 0x0008B504 File Offset: 0x00089704
		public HRegion(double row, double column, double radius, double startAngle, double endAngle)
		{
			IntPtr proc = HalconAPI.PreCall(610);
			HalconAPI.StoreD(proc, 0, row);
			HalconAPI.StoreD(proc, 1, column);
			HalconAPI.StoreD(proc, 2, radius);
			HalconAPI.StoreD(proc, 3, startAngle);
			HalconAPI.StoreD(proc, 4, endAngle);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create a circle.
		///   Modified instance represents: Generated circle.
		/// </summary>
		/// <param name="row">Line index of center. Default: 200.0</param>
		/// <param name="column">Column index of center. Default: 200.0</param>
		/// <param name="radius">Radius of circle. Default: 100.5</param>
		// Token: 0x060015A2 RID: 5538 RVA: 0x0008B574 File Offset: 0x00089774
		public HRegion(HTuple row, HTuple column, HTuple radius)
		{
			IntPtr proc = HalconAPI.PreCall(611);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, column);
			HalconAPI.Store(proc, 2, radius);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HalconAPI.UnpinTuple(radius);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create a circle.
		///   Modified instance represents: Generated circle.
		/// </summary>
		/// <param name="row">Line index of center. Default: 200.0</param>
		/// <param name="column">Column index of center. Default: 200.0</param>
		/// <param name="radius">Radius of circle. Default: 100.5</param>
		// Token: 0x060015A3 RID: 5539 RVA: 0x0008B5E4 File Offset: 0x000897E4
		public HRegion(double row, double column, double radius)
		{
			IntPtr proc = HalconAPI.PreCall(611);
			HalconAPI.StoreD(proc, 0, row);
			HalconAPI.StoreD(proc, 1, column);
			HalconAPI.StoreD(proc, 2, radius);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		// Token: 0x060015A4 RID: 5540 RVA: 0x0008B640 File Offset: 0x00089840
		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
			HSerializedItem hserializedItem = this.SerializeRegion();
			byte[] value = hserializedItem;
			hserializedItem.Dispose();
			info.AddValue("data", value, typeof(byte[]));
		}

		// Token: 0x060015A5 RID: 5541 RVA: 0x0008B678 File Offset: 0x00089878
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HRegion(SerializationInfo info, StreamingContext context)
		{
			HSerializedItem hserializedItem = new HSerializedItem((byte[])info.GetValue("data", typeof(byte[])));
			this.DeserializeRegion(hserializedItem);
			hserializedItem.Dispose();
		}

		/// <summary>Serialize object to binary stream in HALCON format</summary>
		// Token: 0x060015A6 RID: 5542 RVA: 0x0008B6B8 File Offset: 0x000898B8
		public new void Serialize(Stream stream)
		{
			HSerializedItem hserializedItem = this.SerializeRegion();
			hserializedItem.Serialize(stream);
			hserializedItem.Dispose();
		}

		/// <summary>Deserialize object from binary stream in HALCON format</summary>
		// Token: 0x060015A7 RID: 5543 RVA: 0x0008B6CC File Offset: 0x000898CC
		public new static HRegion Deserialize(Stream stream)
		{
			HRegion hregion = new HRegion();
			HSerializedItem hserializedItem = HSerializedItem.Deserialize(stream);
			hregion.DeserializeRegion(hserializedItem);
			hserializedItem.Dispose();
			return hregion;
		}

		// Token: 0x060015A8 RID: 5544 RVA: 0x0008B6F2 File Offset: 0x000898F2
		object ICloneable.Clone()
		{
			return this.Clone();
		}

		// Token: 0x060015A9 RID: 5545 RVA: 0x0008B6FC File Offset: 0x000898FC
		public new HRegion Clone()
		{
			HSerializedItem hserializedItem = this.SerializeRegion();
			HRegion hregion = new HRegion();
			hregion.DeserializeRegion(hserializedItem);
			hserializedItem.Dispose();
			return hregion;
		}

		/// <summary>Returns the intersection of regions</summary>
		// Token: 0x060015AA RID: 5546 RVA: 0x0008B722 File Offset: 0x00089922
		public static HRegion operator &(HRegion region1, HRegion region2)
		{
			return region1.Intersection(region2);
		}

		/// <summary>Returns the union of regions</summary>
		// Token: 0x060015AB RID: 5547 RVA: 0x0008B72B File Offset: 0x0008992B
		public static HRegion operator |(HRegion region1, HRegion region2)
		{
			return region1.Union2(region2);
		}

		/// <summary>Returns the difference of regions</summary>
		// Token: 0x060015AC RID: 5548 RVA: 0x0008B734 File Offset: 0x00089934
		public static HRegion operator /(HRegion region1, HRegion region2)
		{
			return region1.Difference(region2);
		}

		/// <summary>
		///   Returns the recomplement of the region. Note that the result
		///   is not necessarily finite, so you might wish to intersect the
		///   result with the image domain you are interested in.
		/// </summary>
		// Token: 0x060015AD RID: 5549 RVA: 0x0008B73D File Offset: 0x0008993D
		public static HRegion operator !(HRegion region)
		{
			return region.Complement();
		}

		/// <summary>
		///   Returns the intersection of the region and the image domain.
		///   In particular, the result will not exceed the image bounds.
		/// </summary>
		// Token: 0x060015AE RID: 5550 RVA: 0x0008B745 File Offset: 0x00089945
		public static HRegion operator &(HRegion region, HImage image)
		{
			return region.Intersection(image.GetDomain());
		}

		/// <summary>Test if one region is a subset of the other</summary>
		// Token: 0x060015AF RID: 5551 RVA: 0x0008B754 File Offset: 0x00089954
		public static bool operator <=(HRegion region1, HRegion region2)
		{
			int num = region1.CountObj();
			int num2 = region2.CountObj();
			return num == 1 && num2 == 1 && (region1 / region2).Area == 0;
		}

		/// <summary>Test if one region is a subset of the other</summary>
		// Token: 0x060015B0 RID: 5552 RVA: 0x0008B78B File Offset: 0x0008998B
		public static bool operator >=(HRegion region1, HRegion region2)
		{
			return region2 <= region1;
		}

		/// <summary>Returns the Minkowski addition of regions</summary>
		// Token: 0x060015B1 RID: 5553 RVA: 0x0008B794 File Offset: 0x00089994
		public static HRegion operator +(HRegion region1, HRegion region2)
		{
			return region1.MinkowskiAdd1(region2, 1);
		}

		/// <summary>Returns the Minkowski subtraction of regions</summary>
		// Token: 0x060015B2 RID: 5554 RVA: 0x0008B79E File Offset: 0x0008999E
		public static HRegion operator -(HRegion region1, HRegion region2)
		{
			return region1.MinkowskiSub1(region2, 1);
		}

		/// <summary>Dilates the region by the specified radius</summary>
		// Token: 0x060015B3 RID: 5555 RVA: 0x0008B7A8 File Offset: 0x000899A8
		public static HRegion operator +(HRegion region, double radius)
		{
			return region.DilationCircle(radius);
		}

		/// <summary>Dilates the region by the specified radius</summary>
		// Token: 0x060015B4 RID: 5556 RVA: 0x0008B7B1 File Offset: 0x000899B1
		public static HRegion operator +(double radius, HRegion region)
		{
			return region.DilationCircle(radius);
		}

		/// <summary>Erodes the region by the specified radius</summary>
		// Token: 0x060015B5 RID: 5557 RVA: 0x0008B7BA File Offset: 0x000899BA
		public static HRegion operator -(HRegion region, double radius)
		{
			return region.ErosionCircle(radius);
		}

		/// <summary>Translates the region</summary>
		// Token: 0x060015B6 RID: 5558 RVA: 0x0008B7C3 File Offset: 0x000899C3
		public static HRegion operator +(HRegion region, Point p)
		{
			return region.MoveRegion(p.Y, p.X);
		}

		/// <summary>Zooms the region</summary>
		// Token: 0x060015B7 RID: 5559 RVA: 0x0008B7D9 File Offset: 0x000899D9
		public static HRegion operator *(HRegion region, double factor)
		{
			return region.ZoomRegion(factor, factor);
		}

		/// <summary>Zooms the region</summary>
		// Token: 0x060015B8 RID: 5560 RVA: 0x0008B7E3 File Offset: 0x000899E3
		public static HRegion operator *(double factor, HRegion region)
		{
			return region.ZoomRegion(factor, factor);
		}

		/// <summary>Transposes the region</summary>
		// Token: 0x060015B9 RID: 5561 RVA: 0x0008B7ED File Offset: 0x000899ED
		public static HRegion operator -(HRegion region)
		{
			return region.TransposeRegion(0, 0);
		}

		/// <summary>Converts an XLD contour to a filled region</summary>
		// Token: 0x060015BA RID: 5562 RVA: 0x0008B7F7 File Offset: 0x000899F7
		public static implicit operator HRegion(HXLDCont xld)
		{
			return xld.GenRegionContourXld("filled");
		}

		/// <summary>Converts an XLD polygon to a filled region</summary>
		// Token: 0x060015BB RID: 5563 RVA: 0x0008B804 File Offset: 0x00089A04
		public static implicit operator HRegion(HXLDPoly xld)
		{
			return xld.GenRegionPolygonXld("filled");
		}

		/// <summary>Returns an XLD contour representing the region border</summary>
		// Token: 0x060015BC RID: 5564 RVA: 0x0008B811 File Offset: 0x00089A11
		public static implicit operator HXLDCont(HRegion region)
		{
			return region.GenContourRegionXld("border");
		}

		/// <summary>The area of the region</summary>
		// Token: 0x17000050 RID: 80
		// (get) Token: 0x060015BD RID: 5565 RVA: 0x0008B820 File Offset: 0x00089A20
		public HTuple Area
		{
			get
			{
				HTuple htuple;
				HTuple htuple2;
				return this.AreaCenter(out htuple, out htuple2);
			}
		}

		/// <summary>The center row of the region</summary>
		// Token: 0x17000051 RID: 81
		// (get) Token: 0x060015BE RID: 5566 RVA: 0x0008B838 File Offset: 0x00089A38
		public HTuple Row
		{
			get
			{
				HTuple result;
				HTuple htuple;
				this.AreaCenter(out result, out htuple);
				return result;
			}
		}

		/// <summary>The center column of the region</summary>
		// Token: 0x17000052 RID: 82
		// (get) Token: 0x060015BF RID: 5567 RVA: 0x0008B854 File Offset: 0x00089A54
		public HTuple Column
		{
			get
			{
				HTuple htuple;
				HTuple result;
				this.AreaCenter(out htuple, out result);
				return result;
			}
		}

		/// <summary>
		///   Generate XLD contours from regions.
		///   Instance represents: Input regions.
		/// </summary>
		/// <param name="mode">Mode of contour generation. Default: "border"</param>
		/// <returns>Resulting contours.</returns>
		// Token: 0x060015C0 RID: 5568 RVA: 0x0008B870 File Offset: 0x00089A70
		public HXLDCont GenContourRegionXld(string mode)
		{
			IntPtr proc = HalconAPI.PreCall(70);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, mode);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Convert a skeleton into XLD contours.
		///   Instance represents: Skeleton of which the contours are to be determined.
		/// </summary>
		/// <param name="length">Minimum number of points a contour has to have. Default: 1</param>
		/// <param name="mode">Contour filter mode. Default: "filter"</param>
		/// <returns>Resulting contours.</returns>
		// Token: 0x060015C1 RID: 5569 RVA: 0x0008B8C0 File Offset: 0x00089AC0
		public HXLDCont GenContoursSkeletonXld(int length, string mode)
		{
			IntPtr proc = HalconAPI.PreCall(73);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, length);
			HalconAPI.StoreS(proc, 1, mode);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Receive regions over a socket connection.
		///   Modified instance represents: Received regions.
		/// </summary>
		/// <param name="socket">Socket number.</param>
		// Token: 0x060015C2 RID: 5570 RVA: 0x0008B918 File Offset: 0x00089B18
		public void ReceiveRegion(HSocket socket)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(327);
			HalconAPI.Store(proc, 0, socket);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(socket);
		}

		/// <summary>
		///   Send regions over a socket connection.
		///   Instance represents: Regions to be sent.
		/// </summary>
		/// <param name="socket">Socket number.</param>
		// Token: 0x060015C3 RID: 5571 RVA: 0x0008B96C File Offset: 0x00089B6C
		public void SendRegion(HSocket socket)
		{
			IntPtr proc = HalconAPI.PreCall(328);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, socket);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(socket);
		}

		/// <summary>
		///   Create a model to perform 3D-measurements using the sheet-of-light technique.
		///   Instance represents: Region of the images containing the profiles to be processed. If the provided region is not rectangular, its smallest enclosing rectangle will be used.
		/// </summary>
		/// <param name="genParamName">Names of the generic parameters that can be adjusted for the sheet-of-light model. Default: "min_gray"</param>
		/// <param name="genParamValue">Values of the generic parameters that can be adjusted for the sheet-of-light model. Default: 50</param>
		/// <returns>Handle for using and accessing the sheet-of-light model.</returns>
		// Token: 0x060015C4 RID: 5572 RVA: 0x0008B9B0 File Offset: 0x00089BB0
		public HSheetOfLightModel CreateSheetOfLightModel(HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(391);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, genParamName);
			HalconAPI.Store(proc, 1, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HSheetOfLightModel result;
			num = HSheetOfLightModel.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Create a model to perform 3D-measurements using the sheet-of-light technique.
		///   Instance represents: Region of the images containing the profiles to be processed. If the provided region is not rectangular, its smallest enclosing rectangle will be used.
		/// </summary>
		/// <param name="genParamName">Names of the generic parameters that can be adjusted for the sheet-of-light model. Default: "min_gray"</param>
		/// <param name="genParamValue">Values of the generic parameters that can be adjusted for the sheet-of-light model. Default: 50</param>
		/// <returns>Handle for using and accessing the sheet-of-light model.</returns>
		// Token: 0x060015C5 RID: 5573 RVA: 0x0008BA14 File Offset: 0x00089C14
		public HSheetOfLightModel CreateSheetOfLightModel(string genParamName, int genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(391);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, genParamName);
			HalconAPI.StoreI(proc, 1, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HSheetOfLightModel result;
			num = HSheetOfLightModel.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Selects characters from a given region.
		///   Instance represents: Region of text lines in which to select the characters.
		/// </summary>
		/// <param name="dotPrint">Should dot print characters be detected? Default: "false"</param>
		/// <param name="strokeWidth">Stroke width of a character. Default: "medium"</param>
		/// <param name="charWidth">Width of a character. Default: 25</param>
		/// <param name="charHeight">Height of a character. Default: 25</param>
		/// <param name="punctuation">Add punctuation? Default: "false"</param>
		/// <param name="diacriticMarks">Exist diacritic marks? Default: "false"</param>
		/// <param name="partitionMethod">Method to partition neighbored characters. Default: "none"</param>
		/// <param name="partitionLines">Should lines be partitioned? Default: "false"</param>
		/// <param name="fragmentDistance">Distance of fragments. Default: "medium"</param>
		/// <param name="connectFragments">Connect fragments? Default: "false"</param>
		/// <param name="clutterSizeMax">Maximum size of clutter. Default: 0</param>
		/// <param name="stopAfter">Stop execution after this step. Default: "completion"</param>
		/// <returns>Selected characters.</returns>
		// Token: 0x060015C6 RID: 5574 RVA: 0x0008BA6C File Offset: 0x00089C6C
		public HRegion SelectCharacters(string dotPrint, string strokeWidth, HTuple charWidth, HTuple charHeight, string punctuation, string diacriticMarks, string partitionMethod, string partitionLines, string fragmentDistance, string connectFragments, int clutterSizeMax, string stopAfter)
		{
			IntPtr proc = HalconAPI.PreCall(424);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, dotPrint);
			HalconAPI.StoreS(proc, 1, strokeWidth);
			HalconAPI.Store(proc, 2, charWidth);
			HalconAPI.Store(proc, 3, charHeight);
			HalconAPI.StoreS(proc, 4, punctuation);
			HalconAPI.StoreS(proc, 5, diacriticMarks);
			HalconAPI.StoreS(proc, 6, partitionMethod);
			HalconAPI.StoreS(proc, 7, partitionLines);
			HalconAPI.StoreS(proc, 8, fragmentDistance);
			HalconAPI.StoreS(proc, 9, connectFragments);
			HalconAPI.StoreI(proc, 10, clutterSizeMax);
			HalconAPI.StoreS(proc, 11, stopAfter);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(charWidth);
			HalconAPI.UnpinTuple(charHeight);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Segments characters in a given region of an image.
		///   Instance represents: Area in the image where the text lines are located.
		/// </summary>
		/// <param name="image">Input image.</param>
		/// <param name="regionForeground">Region of characters.</param>
		/// <param name="method">Method to segment the characters. Default: "local_auto_shape"</param>
		/// <param name="eliminateLines">Eliminate horizontal and vertical lines? Default: "false"</param>
		/// <param name="dotPrint">Should dot print characters be detected? Default: "false"</param>
		/// <param name="strokeWidth">Stroke width of a character. Default: "medium"</param>
		/// <param name="charWidth">Width of a character. Default: 25</param>
		/// <param name="charHeight">Height of a character. Default: 25</param>
		/// <param name="thresholdOffset">Value to adjust the segmentation. Default: 0</param>
		/// <param name="contrast">Minimum gray value difference between text and background. Default: 10</param>
		/// <param name="usedThreshold">Threshold used to segment the characters.</param>
		/// <returns>Image used for the segmentation.</returns>
		// Token: 0x060015C7 RID: 5575 RVA: 0x0008BB30 File Offset: 0x00089D30
		public HImage SegmentCharacters(HImage image, out HRegion regionForeground, string method, string eliminateLines, string dotPrint, string strokeWidth, HTuple charWidth, HTuple charHeight, int thresholdOffset, int contrast, out HTuple usedThreshold)
		{
			IntPtr proc = HalconAPI.PreCall(425);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.StoreS(proc, 0, method);
			HalconAPI.StoreS(proc, 1, eliminateLines);
			HalconAPI.StoreS(proc, 2, dotPrint);
			HalconAPI.StoreS(proc, 3, strokeWidth);
			HalconAPI.Store(proc, 4, charWidth);
			HalconAPI.Store(proc, 5, charHeight);
			HalconAPI.StoreI(proc, 6, thresholdOffset);
			HalconAPI.StoreI(proc, 7, contrast);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(charWidth);
			HalconAPI.UnpinTuple(charHeight);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HRegion.LoadNew(proc, 2, num, out regionForeground);
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out usedThreshold);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Segments characters in a given region of an image.
		///   Instance represents: Area in the image where the text lines are located.
		/// </summary>
		/// <param name="image">Input image.</param>
		/// <param name="regionForeground">Region of characters.</param>
		/// <param name="method">Method to segment the characters. Default: "local_auto_shape"</param>
		/// <param name="eliminateLines">Eliminate horizontal and vertical lines? Default: "false"</param>
		/// <param name="dotPrint">Should dot print characters be detected? Default: "false"</param>
		/// <param name="strokeWidth">Stroke width of a character. Default: "medium"</param>
		/// <param name="charWidth">Width of a character. Default: 25</param>
		/// <param name="charHeight">Height of a character. Default: 25</param>
		/// <param name="thresholdOffset">Value to adjust the segmentation. Default: 0</param>
		/// <param name="contrast">Minimum gray value difference between text and background. Default: 10</param>
		/// <param name="usedThreshold">Threshold used to segment the characters.</param>
		/// <returns>Image used for the segmentation.</returns>
		// Token: 0x060015C8 RID: 5576 RVA: 0x0008BC04 File Offset: 0x00089E04
		public HImage SegmentCharacters(HImage image, out HRegion regionForeground, string method, string eliminateLines, string dotPrint, string strokeWidth, HTuple charWidth, HTuple charHeight, int thresholdOffset, int contrast, out int usedThreshold)
		{
			IntPtr proc = HalconAPI.PreCall(425);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.StoreS(proc, 0, method);
			HalconAPI.StoreS(proc, 1, eliminateLines);
			HalconAPI.StoreS(proc, 2, dotPrint);
			HalconAPI.StoreS(proc, 3, strokeWidth);
			HalconAPI.Store(proc, 4, charWidth);
			HalconAPI.Store(proc, 5, charHeight);
			HalconAPI.StoreI(proc, 6, thresholdOffset);
			HalconAPI.StoreI(proc, 7, contrast);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(charWidth);
			HalconAPI.UnpinTuple(charHeight);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HRegion.LoadNew(proc, 2, num, out regionForeground);
			num = HalconAPI.LoadI(proc, 0, num, out usedThreshold);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Determines the slant of characters of a text line or paragraph.
		///   Instance represents: Area of text lines.
		/// </summary>
		/// <param name="image">Input image.</param>
		/// <param name="charHeight">Height of the text lines. Default: 25</param>
		/// <param name="slantFrom">Minimum slant of the characters Default: -0.523599</param>
		/// <param name="slantTo">Maximum slant of the characters Default: 0.523599</param>
		/// <returns>Calculated slant of the characters in the region</returns>
		// Token: 0x060015C9 RID: 5577 RVA: 0x0008BCD4 File Offset: 0x00089ED4
		public HTuple TextLineSlant(HImage image, int charHeight, double slantFrom, double slantTo)
		{
			IntPtr proc = HalconAPI.PreCall(426);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.StoreI(proc, 0, charHeight);
			HalconAPI.StoreD(proc, 1, slantFrom);
			HalconAPI.StoreD(proc, 2, slantTo);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Determines the orientation of a text line or paragraph.
		///   Instance represents: Area of text lines.
		/// </summary>
		/// <param name="image">Input image.</param>
		/// <param name="charHeight">Height of the text lines. Default: 25</param>
		/// <param name="orientationFrom">Minimum rotation of the text lines. Default: -0.523599</param>
		/// <param name="orientationTo">Maximum rotation of the text lines. Default: 0.523599</param>
		/// <returns>Calculated rotation angle of the text lines.</returns>
		// Token: 0x060015CA RID: 5578 RVA: 0x0008BD44 File Offset: 0x00089F44
		public HTuple TextLineOrientation(HImage image, int charHeight, double orientationFrom, double orientationTo)
		{
			IntPtr proc = HalconAPI.PreCall(427);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.StoreI(proc, 0, charHeight);
			HalconAPI.StoreD(proc, 1, orientationFrom);
			HalconAPI.StoreD(proc, 2, orientationTo);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Construct classes for class_ndim_norm.
		///   Instance represents: Foreground pixels to be trained.
		/// </summary>
		/// <param name="background">Background pixels to be trained (rejection class).</param>
		/// <param name="image">Multi-channel training image.</param>
		/// <param name="metric">Metric to be used. Default: "euclid"</param>
		/// <param name="distance">Maximum cluster radius. Default: 10.0</param>
		/// <param name="minNumberPercent">The ratio of the number of pixels in a cluster to the total number of pixels (in percent) must be larger than MinNumberPercent (otherwise the cluster is not output). Default: 0.01</param>
		/// <param name="center">Coordinates of all cluster centers.</param>
		/// <param name="quality">Overlap of the rejection class with the classified objects (1: no overlap).</param>
		/// <returns>Cluster radii or half edge lengths.</returns>
		// Token: 0x060015CB RID: 5579 RVA: 0x0008BDB4 File Offset: 0x00089FB4
		public HTuple LearnNdimNorm(HRegion background, HImage image, string metric, HTuple distance, HTuple minNumberPercent, out HTuple center, out double quality)
		{
			IntPtr proc = HalconAPI.PreCall(437);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, background);
			HalconAPI.Store(proc, 3, image);
			HalconAPI.StoreS(proc, 0, metric);
			HalconAPI.Store(proc, 1, distance);
			HalconAPI.Store(proc, 2, minNumberPercent);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(distance);
			HalconAPI.UnpinTuple(minNumberPercent);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out center);
			num = HalconAPI.LoadD(proc, 2, num, out quality);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(background);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Construct classes for class_ndim_norm.
		///   Instance represents: Foreground pixels to be trained.
		/// </summary>
		/// <param name="background">Background pixels to be trained (rejection class).</param>
		/// <param name="image">Multi-channel training image.</param>
		/// <param name="metric">Metric to be used. Default: "euclid"</param>
		/// <param name="distance">Maximum cluster radius. Default: 10.0</param>
		/// <param name="minNumberPercent">The ratio of the number of pixels in a cluster to the total number of pixels (in percent) must be larger than MinNumberPercent (otherwise the cluster is not output). Default: 0.01</param>
		/// <param name="center">Coordinates of all cluster centers.</param>
		/// <param name="quality">Overlap of the rejection class with the classified objects (1: no overlap).</param>
		/// <returns>Cluster radii or half edge lengths.</returns>
		// Token: 0x060015CC RID: 5580 RVA: 0x0008BE68 File Offset: 0x0008A068
		public HTuple LearnNdimNorm(HRegion background, HImage image, string metric, double distance, double minNumberPercent, out HTuple center, out double quality)
		{
			IntPtr proc = HalconAPI.PreCall(437);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, background);
			HalconAPI.Store(proc, 3, image);
			HalconAPI.StoreS(proc, 0, metric);
			HalconAPI.StoreD(proc, 1, distance);
			HalconAPI.StoreD(proc, 2, minNumberPercent);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out center);
			num = HalconAPI.LoadD(proc, 2, num, out quality);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(background);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Train a classificator using a multi-channel image.
		///   Instance represents: Foreground pixels to be trained.
		/// </summary>
		/// <param name="background">Background pixels to be trained (rejection class).</param>
		/// <param name="multiChannelImage">Multi-channel training image.</param>
		/// <param name="classifHandle">Handle of the classifier.</param>
		// Token: 0x060015CD RID: 5581 RVA: 0x0008BF10 File Offset: 0x0008A110
		public void LearnNdimBox(HRegion background, HImage multiChannelImage, HClassBox classifHandle)
		{
			IntPtr proc = HalconAPI.PreCall(438);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, background);
			HalconAPI.Store(proc, 3, multiChannelImage);
			HalconAPI.Store(proc, 0, classifHandle);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(background);
			GC.KeepAlive(multiChannelImage);
			GC.KeepAlive(classifHandle);
		}

		/// <summary>
		///   Transform a region in polar coordinates back to cartesian coordinates.
		///   Instance represents: Input region.
		/// </summary>
		/// <param name="row">Row coordinate of the center of the arc. Default: 256</param>
		/// <param name="column">Column coordinate of the center of the arc. Default: 256</param>
		/// <param name="angleStart">Angle of the ray to map the column coordinate 0 of PolarRegion to. Default: 0.0</param>
		/// <param name="angleEnd">Angle of the ray to map the column coordinate $WidthIn-1$ of PolarRegion to. Default: 6.2831853</param>
		/// <param name="radiusStart">Radius of the circle to map the row coordinate 0 of PolarRegion to. Default: 0</param>
		/// <param name="radiusEnd">Radius of the circle to map the row coordinate $HeightIn-1$ of PolarRegion to. Default: 100</param>
		/// <param name="widthIn">Width of the virtual input image. Default: 512</param>
		/// <param name="heightIn">Height of the virtual input image. Default: 512</param>
		/// <param name="width">Width of the virtual output image. Default: 512</param>
		/// <param name="height">Height of the virtual output image. Default: 512</param>
		/// <param name="interpolation">Interpolation method for the transformation. Default: "nearest_neighbor"</param>
		/// <returns>Output region.</returns>
		// Token: 0x060015CE RID: 5582 RVA: 0x0008BF70 File Offset: 0x0008A170
		public HRegion PolarTransRegionInv(HTuple row, HTuple column, double angleStart, double angleEnd, HTuple radiusStart, HTuple radiusEnd, int widthIn, int heightIn, int width, int height, string interpolation)
		{
			IntPtr proc = HalconAPI.PreCall(475);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, column);
			HalconAPI.StoreD(proc, 2, angleStart);
			HalconAPI.StoreD(proc, 3, angleEnd);
			HalconAPI.Store(proc, 4, radiusStart);
			HalconAPI.Store(proc, 5, radiusEnd);
			HalconAPI.StoreI(proc, 6, widthIn);
			HalconAPI.StoreI(proc, 7, heightIn);
			HalconAPI.StoreI(proc, 8, width);
			HalconAPI.StoreI(proc, 9, height);
			HalconAPI.StoreS(proc, 10, interpolation);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HalconAPI.UnpinTuple(radiusStart);
			HalconAPI.UnpinTuple(radiusEnd);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Transform a region in polar coordinates back to cartesian coordinates.
		///   Instance represents: Input region.
		/// </summary>
		/// <param name="row">Row coordinate of the center of the arc. Default: 256</param>
		/// <param name="column">Column coordinate of the center of the arc. Default: 256</param>
		/// <param name="angleStart">Angle of the ray to map the column coordinate 0 of PolarRegion to. Default: 0.0</param>
		/// <param name="angleEnd">Angle of the ray to map the column coordinate $WidthIn-1$ of PolarRegion to. Default: 6.2831853</param>
		/// <param name="radiusStart">Radius of the circle to map the row coordinate 0 of PolarRegion to. Default: 0</param>
		/// <param name="radiusEnd">Radius of the circle to map the row coordinate $HeightIn-1$ of PolarRegion to. Default: 100</param>
		/// <param name="widthIn">Width of the virtual input image. Default: 512</param>
		/// <param name="heightIn">Height of the virtual input image. Default: 512</param>
		/// <param name="width">Width of the virtual output image. Default: 512</param>
		/// <param name="height">Height of the virtual output image. Default: 512</param>
		/// <param name="interpolation">Interpolation method for the transformation. Default: "nearest_neighbor"</param>
		/// <returns>Output region.</returns>
		// Token: 0x060015CF RID: 5583 RVA: 0x0008C034 File Offset: 0x0008A234
		public HRegion PolarTransRegionInv(double row, double column, double angleStart, double angleEnd, double radiusStart, double radiusEnd, int widthIn, int heightIn, int width, int height, string interpolation)
		{
			IntPtr proc = HalconAPI.PreCall(475);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, row);
			HalconAPI.StoreD(proc, 1, column);
			HalconAPI.StoreD(proc, 2, angleStart);
			HalconAPI.StoreD(proc, 3, angleEnd);
			HalconAPI.StoreD(proc, 4, radiusStart);
			HalconAPI.StoreD(proc, 5, radiusEnd);
			HalconAPI.StoreI(proc, 6, widthIn);
			HalconAPI.StoreI(proc, 7, heightIn);
			HalconAPI.StoreI(proc, 8, width);
			HalconAPI.StoreI(proc, 9, height);
			HalconAPI.StoreS(proc, 10, interpolation);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Transform a region within an annular arc to polar coordinates.
		///   Instance represents: Input region.
		/// </summary>
		/// <param name="row">Row coordinate of the center of the arc. Default: 256</param>
		/// <param name="column">Column coordinate of the center of the arc. Default: 256</param>
		/// <param name="angleStart">Angle of the ray to be mapped to column coordinate 0 of PolarTransRegion. Default: 0.0</param>
		/// <param name="angleEnd">Angle of the ray to be mapped to column coordinate $Width-1$ of PolarTransRegion. Default: 6.2831853</param>
		/// <param name="radiusStart">Radius of the circle to be mapped to row coordinate 0 of PolarTransRegion. Default: 0</param>
		/// <param name="radiusEnd">Radius of the circle to be mapped to row coordinate $Height-1$ of PolarTransRegion. Default: 100</param>
		/// <param name="width">Width of the virtual output image. Default: 512</param>
		/// <param name="height">Height of the virtual output image. Default: 512</param>
		/// <param name="interpolation">Interpolation method for the transformation. Default: "nearest_neighbor"</param>
		/// <returns>Output region.</returns>
		// Token: 0x060015D0 RID: 5584 RVA: 0x0008C0E0 File Offset: 0x0008A2E0
		public HRegion PolarTransRegion(HTuple row, HTuple column, double angleStart, double angleEnd, HTuple radiusStart, HTuple radiusEnd, int width, int height, string interpolation)
		{
			IntPtr proc = HalconAPI.PreCall(476);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, column);
			HalconAPI.StoreD(proc, 2, angleStart);
			HalconAPI.StoreD(proc, 3, angleEnd);
			HalconAPI.Store(proc, 4, radiusStart);
			HalconAPI.Store(proc, 5, radiusEnd);
			HalconAPI.StoreI(proc, 6, width);
			HalconAPI.StoreI(proc, 7, height);
			HalconAPI.StoreS(proc, 8, interpolation);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HalconAPI.UnpinTuple(radiusStart);
			HalconAPI.UnpinTuple(radiusEnd);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Transform a region within an annular arc to polar coordinates.
		///   Instance represents: Input region.
		/// </summary>
		/// <param name="row">Row coordinate of the center of the arc. Default: 256</param>
		/// <param name="column">Column coordinate of the center of the arc. Default: 256</param>
		/// <param name="angleStart">Angle of the ray to be mapped to column coordinate 0 of PolarTransRegion. Default: 0.0</param>
		/// <param name="angleEnd">Angle of the ray to be mapped to column coordinate $Width-1$ of PolarTransRegion. Default: 6.2831853</param>
		/// <param name="radiusStart">Radius of the circle to be mapped to row coordinate 0 of PolarTransRegion. Default: 0</param>
		/// <param name="radiusEnd">Radius of the circle to be mapped to row coordinate $Height-1$ of PolarTransRegion. Default: 100</param>
		/// <param name="width">Width of the virtual output image. Default: 512</param>
		/// <param name="height">Height of the virtual output image. Default: 512</param>
		/// <param name="interpolation">Interpolation method for the transformation. Default: "nearest_neighbor"</param>
		/// <returns>Output region.</returns>
		// Token: 0x060015D1 RID: 5585 RVA: 0x0008C190 File Offset: 0x0008A390
		public HRegion PolarTransRegion(double row, double column, double angleStart, double angleEnd, double radiusStart, double radiusEnd, int width, int height, string interpolation)
		{
			IntPtr proc = HalconAPI.PreCall(476);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, row);
			HalconAPI.StoreD(proc, 1, column);
			HalconAPI.StoreD(proc, 2, angleStart);
			HalconAPI.StoreD(proc, 3, angleEnd);
			HalconAPI.StoreD(proc, 4, radiusStart);
			HalconAPI.StoreD(proc, 5, radiusEnd);
			HalconAPI.StoreI(proc, 6, width);
			HalconAPI.StoreI(proc, 7, height);
			HalconAPI.StoreS(proc, 8, interpolation);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Merge regions from line scan images.
		///   Instance represents: Current input regions.
		/// </summary>
		/// <param name="prevRegions">Merged regions from the previous iteration.</param>
		/// <param name="prevMergedRegions">Regions from the previous iteration which could not be merged with the current ones.</param>
		/// <param name="imageHeight">Height of the line scan images. Default: 512</param>
		/// <param name="mergeBorder">Image line of the current image, which touches the previous image. Default: "top"</param>
		/// <param name="maxImagesRegion">Maximum number of images for a single region. Default: 3</param>
		/// <returns>Current regions, merged with old ones where applicable.</returns>
		// Token: 0x060015D2 RID: 5586 RVA: 0x0008C228 File Offset: 0x0008A428
		public HRegion MergeRegionsLineScan(HRegion prevRegions, out HRegion prevMergedRegions, int imageHeight, string mergeBorder, int maxImagesRegion)
		{
			IntPtr proc = HalconAPI.PreCall(477);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, prevRegions);
			HalconAPI.StoreI(proc, 0, imageHeight);
			HalconAPI.StoreS(proc, 1, mergeBorder);
			HalconAPI.StoreI(proc, 2, maxImagesRegion);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			num = HRegion.LoadNew(proc, 2, num, out prevMergedRegions);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(prevRegions);
			return result;
		}

		/// <summary>
		///   Partition a region into rectangles of approximately equal size.
		///   Instance represents: Region to be partitioned.
		/// </summary>
		/// <param name="width">Width of the individual rectangles.</param>
		/// <param name="height">Height of the individual rectangles.</param>
		/// <returns>Partitioned region.</returns>
		// Token: 0x060015D3 RID: 5587 RVA: 0x0008C2AC File Offset: 0x0008A4AC
		public HRegion PartitionRectangle(double width, double height)
		{
			IntPtr proc = HalconAPI.PreCall(478);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, width);
			HalconAPI.StoreD(proc, 1, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Partition a region horizontally at positions of small vertical extent.
		///   Instance represents: Region to be partitioned.
		/// </summary>
		/// <param name="distance">Approximate width of the resulting region parts.</param>
		/// <param name="percent">Maximum percental shift of the split position. Default: 20</param>
		/// <returns>Partitioned region.</returns>
		// Token: 0x060015D4 RID: 5588 RVA: 0x0008C304 File Offset: 0x0008A504
		public HRegion PartitionDynamic(double distance, double percent)
		{
			IntPtr proc = HalconAPI.PreCall(479);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, distance);
			HalconAPI.StoreD(proc, 1, percent);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Convert regions to a label image.
		///   Instance represents: Regions to be converted.
		/// </summary>
		/// <param name="type">Pixel type of the result image. Default: "int2"</param>
		/// <param name="width">Width of the image to be generated. Default: 512</param>
		/// <param name="height">Height of the image to be generated. Default: 512</param>
		/// <returns>Result image of dimension Width * Height containing the converted regions.</returns>
		// Token: 0x060015D5 RID: 5589 RVA: 0x0008C35C File Offset: 0x0008A55C
		public HImage RegionToLabel(string type, int width, int height)
		{
			IntPtr proc = HalconAPI.PreCall(480);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, type);
			HalconAPI.StoreI(proc, 1, width);
			HalconAPI.StoreI(proc, 2, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Convert a region into a binary byte-image.
		///   Instance represents: Regions to be converted.
		/// </summary>
		/// <param name="foregroundGray">Gray value in which the regions are displayed. Default: 255</param>
		/// <param name="backgroundGray">Gray value in which the background is displayed. Default: 0</param>
		/// <param name="width">Width of the image to be generated. Default: 512</param>
		/// <param name="height">Height of the image to be generated. Default: 512</param>
		/// <returns>Result image of dimension Width * Height containing the converted regions.</returns>
		// Token: 0x060015D6 RID: 5590 RVA: 0x0008C3BC File Offset: 0x0008A5BC
		public HImage RegionToBin(int foregroundGray, int backgroundGray, int width, int height)
		{
			IntPtr proc = HalconAPI.PreCall(481);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, foregroundGray);
			HalconAPI.StoreI(proc, 1, backgroundGray);
			HalconAPI.StoreI(proc, 2, width);
			HalconAPI.StoreI(proc, 3, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Return the union of two regions.
		///   Instance represents: Region for which the union with all regions in Region2 is to be computed.
		/// </summary>
		/// <param name="region2">Regions which should be added to Region1.</param>
		/// <returns>Resulting regions.</returns>
		// Token: 0x060015D7 RID: 5591 RVA: 0x0008C428 File Offset: 0x0008A628
		public HRegion Union2(HRegion region2)
		{
			IntPtr proc = HalconAPI.PreCall(482);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, region2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(region2);
			return result;
		}

		/// <summary>
		///   Return the union of all input regions.
		///   Instance represents: Regions of which the union is to be computed.
		/// </summary>
		/// <returns>Union of all input regions.</returns>
		// Token: 0x060015D8 RID: 5592 RVA: 0x0008C480 File Offset: 0x0008A680
		public HRegion Union1()
		{
			IntPtr proc = HalconAPI.PreCall(483);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the closest-point transformation of a region.
		///   Instance represents: Region for which the distance to the border is computed.
		/// </summary>
		/// <param name="closestPoints">Image containing the coordinates of the closest points.</param>
		/// <param name="metric">Type of metric to be used for the closest-point transformation. Default: "city-block"</param>
		/// <param name="foreground">Compute the distance for pixels inside (true) or outside (false) the input region. Default: "true"</param>
		/// <param name="closestPointMode">Mode in which the coordinates of the closest points are returned. Default: "absolute"</param>
		/// <param name="width">Width of the output images. Default: 640</param>
		/// <param name="height">Height of the output images. Default: 480</param>
		/// <returns>Image containing the distance information.</returns>
		// Token: 0x060015D9 RID: 5593 RVA: 0x0008C4C8 File Offset: 0x0008A6C8
		public HImage ClosestPointTransform(out HImage closestPoints, string metric, string foreground, string closestPointMode, int width, int height)
		{
			IntPtr proc = HalconAPI.PreCall(484);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, metric);
			HalconAPI.StoreS(proc, 1, foreground);
			HalconAPI.StoreS(proc, 2, closestPointMode);
			HalconAPI.StoreI(proc, 3, width);
			HalconAPI.StoreI(proc, 4, height);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out closestPoints);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the distance transformation of a region.
		///   Instance represents: Region for which the distance to the border is computed.
		/// </summary>
		/// <param name="metric">Type of metric to be used for the distance transformation. Default: "city-block"</param>
		/// <param name="foreground">Compute the distance for pixels inside (true) or outside (false) the input region. Default: "true"</param>
		/// <param name="width">Width of the output image. Default: 640</param>
		/// <param name="height">Height of the output image. Default: 480</param>
		/// <returns>Image containing the distance information.</returns>
		// Token: 0x060015DA RID: 5594 RVA: 0x0008C550 File Offset: 0x0008A750
		public HImage DistanceTransform(string metric, string foreground, int width, int height)
		{
			IntPtr proc = HalconAPI.PreCall(485);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, metric);
			HalconAPI.StoreS(proc, 1, foreground);
			HalconAPI.StoreI(proc, 2, width);
			HalconAPI.StoreI(proc, 3, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the skeleton of a region.
		///   Instance represents: Region to be thinned.
		/// </summary>
		/// <returns>Resulting skeleton.</returns>
		// Token: 0x060015DB RID: 5595 RVA: 0x0008C5BC File Offset: 0x0008A7BC
		public HRegion Skeleton()
		{
			IntPtr proc = HalconAPI.PreCall(486);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Apply a projective transformation to a region.
		///   Instance represents: Input regions.
		/// </summary>
		/// <param name="homMat2D">Homogeneous projective transformation matrix.</param>
		/// <param name="interpolation">Interpolation method for the transformation. Default: "bilinear"</param>
		/// <returns>Output regions.</returns>
		// Token: 0x060015DC RID: 5596 RVA: 0x0008C604 File Offset: 0x0008A804
		public HRegion ProjectiveTransRegion(HHomMat2D homMat2D, string interpolation)
		{
			IntPtr proc = HalconAPI.PreCall(487);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, homMat2D);
			HalconAPI.StoreS(proc, 1, interpolation);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(homMat2D);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Apply an arbitrary affine 2D transformation to regions.
		///   Instance represents: Region(s) to be rotated and scaled.
		/// </summary>
		/// <param name="homMat2D">Input transformation matrix.</param>
		/// <param name="interpolate">Should the transformation be done using interpolation? Default: "nearest_neighbor"</param>
		/// <returns>Transformed output region(s).</returns>
		// Token: 0x060015DD RID: 5597 RVA: 0x0008C66C File Offset: 0x0008A86C
		public HRegion AffineTransRegion(HHomMat2D homMat2D, string interpolate)
		{
			IntPtr proc = HalconAPI.PreCall(488);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, homMat2D);
			HalconAPI.StoreS(proc, 1, interpolate);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(homMat2D);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Reflect a region about an axis.
		///   Instance represents: Region(s) to be reflected.
		/// </summary>
		/// <param name="mode">Axis of symmetry. Default: "row"</param>
		/// <param name="widthHeight">Twice the coordinate of the axis of symmetry. Default: 512</param>
		/// <returns>Reflected region(s).</returns>
		// Token: 0x060015DE RID: 5598 RVA: 0x0008C6D4 File Offset: 0x0008A8D4
		public HRegion MirrorRegion(string mode, int widthHeight)
		{
			IntPtr proc = HalconAPI.PreCall(489);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, mode);
			HalconAPI.StoreI(proc, 1, widthHeight);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Zoom a region.
		///   Instance represents: Region(s) to be zoomed.
		/// </summary>
		/// <param name="scaleWidth">Scale factor in x-direction. Default: 2.0</param>
		/// <param name="scaleHeight">Scale factor in y-direction. Default: 2.0</param>
		/// <returns>Zoomed region(s).</returns>
		// Token: 0x060015DF RID: 5599 RVA: 0x0008C72C File Offset: 0x0008A92C
		public HRegion ZoomRegion(double scaleWidth, double scaleHeight)
		{
			IntPtr proc = HalconAPI.PreCall(490);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, scaleWidth);
			HalconAPI.StoreD(proc, 1, scaleHeight);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Translate a region.
		///   Instance represents: Region(s) to be moved.
		/// </summary>
		/// <param name="row">Row coordinate of the vector by which the region is to be moved. Default: 30</param>
		/// <param name="column">Row coordinate of the vector by which the region is to be moved. Default: 30</param>
		/// <returns>Translated region(s).</returns>
		// Token: 0x060015E0 RID: 5600 RVA: 0x0008C784 File Offset: 0x0008A984
		public HRegion MoveRegion(int row, int column)
		{
			IntPtr proc = HalconAPI.PreCall(491);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, row);
			HalconAPI.StoreI(proc, 1, column);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Find junctions and end points in a skeleton.
		///   Instance represents: Input skeletons.
		/// </summary>
		/// <param name="juncPoints">Extracted junctions.</param>
		/// <returns>Extracted end points.</returns>
		// Token: 0x060015E1 RID: 5601 RVA: 0x0008C7DC File Offset: 0x0008A9DC
		public HRegion JunctionsSkeleton(out HRegion juncPoints)
		{
			IntPtr proc = HalconAPI.PreCall(492);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			num = HRegion.LoadNew(proc, 2, num, out juncPoints);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calculate the intersection of two regions.
		///   Instance represents: Regions to be intersected with all regions in Region2.
		/// </summary>
		/// <param name="region2">Regions with which Region1 is intersected.</param>
		/// <returns>Result of the intersection.</returns>
		// Token: 0x060015E2 RID: 5602 RVA: 0x0008C838 File Offset: 0x0008AA38
		public HRegion Intersection(HRegion region2)
		{
			IntPtr proc = HalconAPI.PreCall(493);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, region2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(region2);
			return result;
		}

		/// <summary>
		///   Partition the image plane using given regions.
		///   Instance represents: Regions for which the separating lines are to be determined.
		/// </summary>
		/// <param name="mode">Mode of operation. Default: "mixed"</param>
		/// <returns>Output region containing the separating lines.</returns>
		// Token: 0x060015E3 RID: 5603 RVA: 0x0008C890 File Offset: 0x0008AA90
		public HRegion Interjacent(string mode)
		{
			IntPtr proc = HalconAPI.PreCall(494);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, mode);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Fill up holes in regions.
		///   Instance represents: Input regions containing holes.
		/// </summary>
		/// <returns>Regions without holes.</returns>
		// Token: 0x060015E4 RID: 5604 RVA: 0x0008C8E0 File Offset: 0x0008AAE0
		public HRegion FillUp()
		{
			IntPtr proc = HalconAPI.PreCall(495);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Fill up holes in regions having given shape features.
		///   Instance represents: Input region(s).
		/// </summary>
		/// <param name="feature">Shape feature used. Default: "area"</param>
		/// <param name="min">Minimum value for Feature. Default: 1.0</param>
		/// <param name="max">Maximum value for Feature. Default: 100.0</param>
		/// <returns>Output region(s) with filled holes.</returns>
		// Token: 0x060015E5 RID: 5605 RVA: 0x0008C928 File Offset: 0x0008AB28
		public HRegion FillUpShape(string feature, HTuple min, HTuple max)
		{
			IntPtr proc = HalconAPI.PreCall(496);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, feature);
			HalconAPI.Store(proc, 1, min);
			HalconAPI.Store(proc, 2, max);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(min);
			HalconAPI.UnpinTuple(max);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Fill up holes in regions having given shape features.
		///   Instance represents: Input region(s).
		/// </summary>
		/// <param name="feature">Shape feature used. Default: "area"</param>
		/// <param name="min">Minimum value for Feature. Default: 1.0</param>
		/// <param name="max">Maximum value for Feature. Default: 100.0</param>
		/// <returns>Output region(s) with filled holes.</returns>
		// Token: 0x060015E6 RID: 5606 RVA: 0x0008C994 File Offset: 0x0008AB94
		public HRegion FillUpShape(string feature, double min, double max)
		{
			IntPtr proc = HalconAPI.PreCall(496);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, feature);
			HalconAPI.StoreD(proc, 1, min);
			HalconAPI.StoreD(proc, 2, max);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Fill gaps between regions or split overlapping regions.
		///   Instance represents: Regions for which the gaps are to be closed, or which are to be separated.
		/// </summary>
		/// <param name="forbiddenArea">Regions in which no expansion takes place.</param>
		/// <param name="iterations">Number of iterations. Default: "maximal"</param>
		/// <param name="mode">Expansion mode. Default: "image"</param>
		/// <returns>Expanded or separated regions.</returns>
		// Token: 0x060015E7 RID: 5607 RVA: 0x0008C9F4 File Offset: 0x0008ABF4
		public HRegion ExpandRegion(HRegion forbiddenArea, HTuple iterations, string mode)
		{
			IntPtr proc = HalconAPI.PreCall(497);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, forbiddenArea);
			HalconAPI.Store(proc, 0, iterations);
			HalconAPI.StoreS(proc, 1, mode);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(iterations);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(forbiddenArea);
			return result;
		}

		/// <summary>
		///   Fill gaps between regions or split overlapping regions.
		///   Instance represents: Regions for which the gaps are to be closed, or which are to be separated.
		/// </summary>
		/// <param name="forbiddenArea">Regions in which no expansion takes place.</param>
		/// <param name="iterations">Number of iterations. Default: "maximal"</param>
		/// <param name="mode">Expansion mode. Default: "image"</param>
		/// <returns>Expanded or separated regions.</returns>
		// Token: 0x060015E8 RID: 5608 RVA: 0x0008CA60 File Offset: 0x0008AC60
		public HRegion ExpandRegion(HRegion forbiddenArea, int iterations, string mode)
		{
			IntPtr proc = HalconAPI.PreCall(497);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, forbiddenArea);
			HalconAPI.StoreI(proc, 0, iterations);
			HalconAPI.StoreS(proc, 1, mode);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(forbiddenArea);
			return result;
		}

		/// <summary>
		///   Clip a region relative to its smallest surrounding rectangle.
		///   Instance represents: Regions to be clipped.
		/// </summary>
		/// <param name="top">Number of rows clipped at the top. Default: 1</param>
		/// <param name="bottom">Number of rows clipped at the bottom. Default: 1</param>
		/// <param name="left">Number of columns clipped at the left. Default: 1</param>
		/// <param name="right">Number of columns clipped at the right. Default: 1</param>
		/// <returns>Clipped regions.</returns>
		// Token: 0x060015E9 RID: 5609 RVA: 0x0008CAC8 File Offset: 0x0008ACC8
		public HRegion ClipRegionRel(int top, int bottom, int left, int right)
		{
			IntPtr proc = HalconAPI.PreCall(498);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, top);
			HalconAPI.StoreI(proc, 1, bottom);
			HalconAPI.StoreI(proc, 2, left);
			HalconAPI.StoreI(proc, 3, right);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Clip a region to a rectangle.
		///   Instance represents: Region to be clipped.
		/// </summary>
		/// <param name="row1">Row coordinate of the upper left corner of the rectangle. Default: 0</param>
		/// <param name="column1">Column coordinate of the upper left corner of the rectangle. Default: 0</param>
		/// <param name="row2">Row coordinate of the lower right corner of the rectangle. Default: 256</param>
		/// <param name="column2">Column coordinate of the lower right corner of the rectangle. Default: 256</param>
		/// <returns>Clipped regions.</returns>
		// Token: 0x060015EA RID: 5610 RVA: 0x0008CB34 File Offset: 0x0008AD34
		public HRegion ClipRegion(int row1, int column1, int row2, int column2)
		{
			IntPtr proc = HalconAPI.PreCall(499);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, row1);
			HalconAPI.StoreI(proc, 1, column1);
			HalconAPI.StoreI(proc, 2, row2);
			HalconAPI.StoreI(proc, 3, column2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Rank operator for regions.
		///   Instance represents: Region(s) to be transformed.
		/// </summary>
		/// <param name="width">Width of the filter mask. Default: 15</param>
		/// <param name="height">Height of the filter mask. Default: 15</param>
		/// <param name="number">Minimum number of points lying within the filter mask. Default: 70</param>
		/// <returns>Resulting region(s).</returns>
		// Token: 0x060015EB RID: 5611 RVA: 0x0008CBA0 File Offset: 0x0008ADA0
		public HRegion RankRegion(int width, int height, int number)
		{
			IntPtr proc = HalconAPI.PreCall(500);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, width);
			HalconAPI.StoreI(proc, 1, height);
			HalconAPI.StoreI(proc, 2, number);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute connected components of a region.
		///   Instance represents: Input region.
		/// </summary>
		/// <returns>Connected components.</returns>
		// Token: 0x060015EC RID: 5612 RVA: 0x0008CC00 File Offset: 0x0008AE00
		public HRegion Connection()
		{
			IntPtr proc = HalconAPI.PreCall(501);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calculate the symmetric difference of two regions.
		///   Instance represents: Input region 1.
		/// </summary>
		/// <param name="region2">Input region 2.</param>
		/// <returns>Resulting region.</returns>
		// Token: 0x060015ED RID: 5613 RVA: 0x0008CC48 File Offset: 0x0008AE48
		public HRegion SymmDifference(HRegion region2)
		{
			IntPtr proc = HalconAPI.PreCall(502);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, region2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(region2);
			return result;
		}

		/// <summary>
		///   Calculate the difference of two regions.
		///   Instance represents: Regions to be processed.
		/// </summary>
		/// <param name="sub">The union of these regions is subtracted from Region.</param>
		/// <returns>Resulting region.</returns>
		// Token: 0x060015EE RID: 5614 RVA: 0x0008CCA0 File Offset: 0x0008AEA0
		public HRegion Difference(HRegion sub)
		{
			IntPtr proc = HalconAPI.PreCall(503);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, sub);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(sub);
			return result;
		}

		/// <summary>
		///   Return the complement of a region.
		///   Instance represents: Input region(s).
		/// </summary>
		/// <returns>Complemented regions.</returns>
		// Token: 0x060015EF RID: 5615 RVA: 0x0008CCF8 File Offset: 0x0008AEF8
		public HRegion Complement()
		{
			IntPtr proc = HalconAPI.PreCall(504);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Determine the connected components of the background of given regions.
		///   Instance represents: Input regions.
		/// </summary>
		/// <returns>Connected components of the background.</returns>
		// Token: 0x060015F0 RID: 5616 RVA: 0x0008CD40 File Offset: 0x0008AF40
		public HRegion BackgroundSeg()
		{
			IntPtr proc = HalconAPI.PreCall(505);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Generate a region having a given Hamming distance.
		///   Instance represents: Region to be modified.
		/// </summary>
		/// <param name="width">Width of the region to be changed. Default: 100</param>
		/// <param name="height">Height of the region to be changed. Default: 100</param>
		/// <param name="distance">Hamming distance between the old and new regions. Default: 1000</param>
		/// <returns>Regions having the required Hamming distance.</returns>
		// Token: 0x060015F1 RID: 5617 RVA: 0x0008CD88 File Offset: 0x0008AF88
		public HRegion HammingChangeRegion(int width, int height, int distance)
		{
			IntPtr proc = HalconAPI.PreCall(506);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, width);
			HalconAPI.StoreI(proc, 1, height);
			HalconAPI.StoreI(proc, 2, distance);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Remove noise from a region.
		///   Instance represents: Regions to be modified.
		/// </summary>
		/// <param name="type">Mode of noise removal. Default: "n_4"</param>
		/// <returns>Less noisy regions.</returns>
		// Token: 0x060015F2 RID: 5618 RVA: 0x0008CDE8 File Offset: 0x0008AFE8
		public HRegion RemoveNoiseRegion(string type)
		{
			IntPtr proc = HalconAPI.PreCall(507);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, type);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Transform the shape of a region.
		///   Instance represents: Regions to be transformed.
		/// </summary>
		/// <param name="type">Type of transformation. Default: "convex"</param>
		/// <returns>Transformed regions.</returns>
		// Token: 0x060015F3 RID: 5619 RVA: 0x0008CE38 File Offset: 0x0008B038
		public HRegion ShapeTrans(string type)
		{
			IntPtr proc = HalconAPI.PreCall(508);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, type);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Fill gaps between regions (depending on gray value or color) or split overlapping regions.
		///   Instance represents: Regions for which the gaps are to be closed, or which are to be separated.
		/// </summary>
		/// <param name="image">Image (possibly multi-channel) for gray value or color comparison.</param>
		/// <param name="forbiddenArea">Regions in which no expansion takes place.</param>
		/// <param name="iterations">Number of iterations. Default: "maximal"</param>
		/// <param name="mode">Expansion mode. Default: "image"</param>
		/// <param name="threshold">Maximum difference between the gray value or color at the region's border and a candidate for expansion. Default: 32</param>
		/// <returns>Expanded or separated regions.</returns>
		// Token: 0x060015F4 RID: 5620 RVA: 0x0008CE88 File Offset: 0x0008B088
		public HRegion ExpandGray(HImage image, HRegion forbiddenArea, HTuple iterations, string mode, HTuple threshold)
		{
			IntPtr proc = HalconAPI.PreCall(509);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 3, forbiddenArea);
			HalconAPI.Store(proc, 0, iterations);
			HalconAPI.StoreS(proc, 1, mode);
			HalconAPI.Store(proc, 2, threshold);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(iterations);
			HalconAPI.UnpinTuple(threshold);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			GC.KeepAlive(forbiddenArea);
			return result;
		}

		/// <summary>
		///   Fill gaps between regions (depending on gray value or color) or split overlapping regions.
		///   Instance represents: Regions for which the gaps are to be closed, or which are to be separated.
		/// </summary>
		/// <param name="image">Image (possibly multi-channel) for gray value or color comparison.</param>
		/// <param name="forbiddenArea">Regions in which no expansion takes place.</param>
		/// <param name="iterations">Number of iterations. Default: "maximal"</param>
		/// <param name="mode">Expansion mode. Default: "image"</param>
		/// <param name="threshold">Maximum difference between the gray value or color at the region's border and a candidate for expansion. Default: 32</param>
		/// <returns>Expanded or separated regions.</returns>
		// Token: 0x060015F5 RID: 5621 RVA: 0x0008CF14 File Offset: 0x0008B114
		public HRegion ExpandGray(HImage image, HRegion forbiddenArea, string iterations, string mode, int threshold)
		{
			IntPtr proc = HalconAPI.PreCall(509);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 3, forbiddenArea);
			HalconAPI.StoreS(proc, 0, iterations);
			HalconAPI.StoreS(proc, 1, mode);
			HalconAPI.StoreI(proc, 2, threshold);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			GC.KeepAlive(forbiddenArea);
			return result;
		}

		/// <summary>
		///   Fill gaps between regions (depending on gray value or color) or split overlapping regions.
		///   Instance represents: Regions for which the gaps are to be closed, or which are to be separated.
		/// </summary>
		/// <param name="image">Image (possibly multi-channel) for gray value or color comparison.</param>
		/// <param name="forbiddenArea">Regions in which no expansion takes place.</param>
		/// <param name="iterations">Number of iterations. Default: "maximal"</param>
		/// <param name="mode">Expansion mode. Default: "image"</param>
		/// <param name="refGray">Reference gray value or color for comparison. Default: 128</param>
		/// <param name="threshold">Maximum difference between the reference gray value or color and a candidate for expansion. Default: 32</param>
		/// <returns>Expanded or separated regions.</returns>
		// Token: 0x060015F6 RID: 5622 RVA: 0x0008CF94 File Offset: 0x0008B194
		public HRegion ExpandGrayRef(HImage image, HRegion forbiddenArea, HTuple iterations, string mode, HTuple refGray, HTuple threshold)
		{
			IntPtr proc = HalconAPI.PreCall(510);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 3, forbiddenArea);
			HalconAPI.Store(proc, 0, iterations);
			HalconAPI.StoreS(proc, 1, mode);
			HalconAPI.Store(proc, 2, refGray);
			HalconAPI.Store(proc, 3, threshold);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(iterations);
			HalconAPI.UnpinTuple(refGray);
			HalconAPI.UnpinTuple(threshold);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			GC.KeepAlive(forbiddenArea);
			return result;
		}

		/// <summary>
		///   Fill gaps between regions (depending on gray value or color) or split overlapping regions.
		///   Instance represents: Regions for which the gaps are to be closed, or which are to be separated.
		/// </summary>
		/// <param name="image">Image (possibly multi-channel) for gray value or color comparison.</param>
		/// <param name="forbiddenArea">Regions in which no expansion takes place.</param>
		/// <param name="iterations">Number of iterations. Default: "maximal"</param>
		/// <param name="mode">Expansion mode. Default: "image"</param>
		/// <param name="refGray">Reference gray value or color for comparison. Default: 128</param>
		/// <param name="threshold">Maximum difference between the reference gray value or color and a candidate for expansion. Default: 32</param>
		/// <returns>Expanded or separated regions.</returns>
		// Token: 0x060015F7 RID: 5623 RVA: 0x0008D030 File Offset: 0x0008B230
		public HRegion ExpandGrayRef(HImage image, HRegion forbiddenArea, string iterations, string mode, int refGray, int threshold)
		{
			IntPtr proc = HalconAPI.PreCall(510);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 3, forbiddenArea);
			HalconAPI.StoreS(proc, 0, iterations);
			HalconAPI.StoreS(proc, 1, mode);
			HalconAPI.StoreI(proc, 2, refGray);
			HalconAPI.StoreI(proc, 3, threshold);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			GC.KeepAlive(forbiddenArea);
			return result;
		}

		/// <summary>
		///   Split lines represented by one pixel wide, non-branching lines.
		///   Instance represents: Input lines (represented by 1 pixel wide, non-branching regions).
		/// </summary>
		/// <param name="maxDistance">Maximum distance of the line points to the line segment connecting both end points. Default: 3</param>
		/// <param name="beginRow">Row coordinates of the start points of the output lines.</param>
		/// <param name="beginCol">Column coordinates of the start points of the output lines.</param>
		/// <param name="endRow">Row coordinates of the end points of the output lines.</param>
		/// <param name="endCol">Column coordinates of the end points of the output lines.</param>
		// Token: 0x060015F8 RID: 5624 RVA: 0x0008D0B8 File Offset: 0x0008B2B8
		public void SplitSkeletonLines(int maxDistance, out HTuple beginRow, out HTuple beginCol, out HTuple endRow, out HTuple endCol)
		{
			IntPtr proc = HalconAPI.PreCall(511);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, maxDistance);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out beginRow);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out beginCol);
			num = HTuple.LoadNew(proc, 2, HTupleType.INTEGER, num, out endRow);
			num = HTuple.LoadNew(proc, 3, HTupleType.INTEGER, num, out endCol);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Split lines represented by one pixel wide, non-branching regions.
		///   Instance represents: Input lines (represented by 1 pixel wide, non-branching regions).
		/// </summary>
		/// <param name="maxDistance">Maximum distance of the line points to the line segment connecting both end points. Default: 3</param>
		/// <returns>Split lines.</returns>
		// Token: 0x060015F9 RID: 5625 RVA: 0x0008D144 File Offset: 0x0008B344
		public HRegion SplitSkeletonRegion(int maxDistance)
		{
			IntPtr proc = HalconAPI.PreCall(512);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, maxDistance);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Convert a histogram into a region.
		///   Modified instance represents: Region containing the histogram.
		/// </summary>
		/// <param name="histogram">Input histogram.</param>
		/// <param name="row">Row coordinate of the center of the histogram. Default: 255</param>
		/// <param name="column">Column coordinate of the center of the histogram. Default: 255</param>
		/// <param name="scale">Scale factor for the histogram. Default: 1</param>
		// Token: 0x060015FA RID: 5626 RVA: 0x0008D194 File Offset: 0x0008B394
		public void GenRegionHisto(HTuple histogram, int row, int column, int scale)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(513);
			HalconAPI.Store(proc, 0, histogram);
			HalconAPI.StoreI(proc, 1, row);
			HalconAPI.StoreI(proc, 2, column);
			HalconAPI.StoreI(proc, 3, scale);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(histogram);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Eliminate runs of a given length.
		///   Instance represents: Region to be clipped.
		/// </summary>
		/// <param name="elimShorter">All runs which are shorter are eliminated. Default: 3</param>
		/// <param name="elimLonger">All runs which are longer are eliminated. Default: 1000</param>
		/// <returns>Clipped regions.</returns>
		// Token: 0x060015FB RID: 5627 RVA: 0x0008D200 File Offset: 0x0008B400
		public HRegion EliminateRuns(int elimShorter, int elimLonger)
		{
			IntPtr proc = HalconAPI.PreCall(514);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, elimShorter);
			HalconAPI.StoreI(proc, 1, elimLonger);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calculate the difference of two object tuples.
		///   Instance represents: Object tuple 1.
		/// </summary>
		/// <param name="objectsSub">Object tuple 2.</param>
		/// <returns>Objects from Objects that are not part of ObjectsSub.</returns>
		// Token: 0x060015FC RID: 5628 RVA: 0x0008D258 File Offset: 0x0008B458
		public HRegion ObjDiff(HRegion objectsSub)
		{
			IntPtr proc = HalconAPI.PreCall(573);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objectsSub);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objectsSub);
			return result;
		}

		/// <summary>
		///   Paint regions into an image.
		///   Instance represents: Regions to be painted into the input image.
		/// </summary>
		/// <param name="image">Image in which the regions are to be painted.</param>
		/// <param name="grayval">Desired gray values of the regions. Default: 255.0</param>
		/// <param name="type">Paint regions filled or as boundaries. Default: "fill"</param>
		/// <returns>Image containing the result.</returns>
		// Token: 0x060015FD RID: 5629 RVA: 0x0008D2B0 File Offset: 0x0008B4B0
		public HImage PaintRegion(HImage image, HTuple grayval, string type)
		{
			IntPtr proc = HalconAPI.PreCall(576);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, grayval);
			HalconAPI.StoreS(proc, 1, type);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(grayval);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Paint regions into an image.
		///   Instance represents: Regions to be painted into the input image.
		/// </summary>
		/// <param name="image">Image in which the regions are to be painted.</param>
		/// <param name="grayval">Desired gray values of the regions. Default: 255.0</param>
		/// <param name="type">Paint regions filled or as boundaries. Default: "fill"</param>
		/// <returns>Image containing the result.</returns>
		// Token: 0x060015FE RID: 5630 RVA: 0x0008D31C File Offset: 0x0008B51C
		public HImage PaintRegion(HImage image, double grayval, string type)
		{
			IntPtr proc = HalconAPI.PreCall(576);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.StoreD(proc, 0, grayval);
			HalconAPI.StoreS(proc, 1, type);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Overpaint regions in an image.
		///   Instance represents: Regions to be painted into the input image.
		/// </summary>
		/// <param name="image">Image in which the regions are to be painted.</param>
		/// <param name="grayval">Desired gray values of the regions. Default: 255.0</param>
		/// <param name="type">Paint regions filled or as boundaries. Default: "fill"</param>
		// Token: 0x060015FF RID: 5631 RVA: 0x0008D384 File Offset: 0x0008B584
		public void OverpaintRegion(HImage image, HTuple grayval, string type)
		{
			IntPtr proc = HalconAPI.PreCall(577);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.Store(proc, 0, grayval);
			HalconAPI.StoreS(proc, 1, type);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(grayval);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
		}

		/// <summary>
		///   Overpaint regions in an image.
		///   Instance represents: Regions to be painted into the input image.
		/// </summary>
		/// <param name="image">Image in which the regions are to be painted.</param>
		/// <param name="grayval">Desired gray values of the regions. Default: 255.0</param>
		/// <param name="type">Paint regions filled or as boundaries. Default: "fill"</param>
		// Token: 0x06001600 RID: 5632 RVA: 0x0008D3DC File Offset: 0x0008B5DC
		public void OverpaintRegion(HImage image, double grayval, string type)
		{
			IntPtr proc = HalconAPI.PreCall(577);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.StoreD(proc, 0, grayval);
			HalconAPI.StoreS(proc, 1, type);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
		}

		/// <summary>
		///   Copy an iconic object in the HALCON database.
		///   Instance represents: Objects to be copied.
		/// </summary>
		/// <param name="index">Starting index of the objects to be copied. Default: 1</param>
		/// <param name="numObj">Number of objects to be copied or -1. Default: 1</param>
		/// <returns>Copied objects.</returns>
		// Token: 0x06001601 RID: 5633 RVA: 0x0008D430 File Offset: 0x0008B630
		public new HRegion CopyObj(int index, int numObj)
		{
			IntPtr proc = HalconAPI.PreCall(583);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, index);
			HalconAPI.StoreI(proc, 1, numObj);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Concatenate two iconic object tuples.
		///   Instance represents: Object tuple 1.
		/// </summary>
		/// <param name="objects2">Object tuple 2.</param>
		/// <returns>Concatenated objects.</returns>
		// Token: 0x06001602 RID: 5634 RVA: 0x0008D488 File Offset: 0x0008B688
		public HRegion ConcatObj(HRegion objects2)
		{
			IntPtr proc = HalconAPI.PreCall(584);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objects2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objects2);
			return result;
		}

		/// <summary>
		///   Select objects from an object tuple.
		///   Instance represents: Input objects.
		/// </summary>
		/// <param name="index">Indices of the objects to be selected. Default: 1</param>
		/// <returns>Selected objects.</returns>
		// Token: 0x06001603 RID: 5635 RVA: 0x0008D4E0 File Offset: 0x0008B6E0
		public new HRegion SelectObj(HTuple index)
		{
			IntPtr proc = HalconAPI.PreCall(587);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(index);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Select objects from an object tuple.
		///   Instance represents: Input objects.
		/// </summary>
		/// <param name="index">Indices of the objects to be selected. Default: 1</param>
		/// <returns>Selected objects.</returns>
		// Token: 0x06001604 RID: 5636 RVA: 0x0008D538 File Offset: 0x0008B738
		public new HRegion SelectObj(int index)
		{
			IntPtr proc = HalconAPI.PreCall(587);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compare iconic objects regarding equality.
		///   Instance represents: Reference objects.
		/// </summary>
		/// <param name="objects2">Test objects.</param>
		/// <param name="epsilon">Maximum allowed difference between two gray values or  coordinates etc. Default: 0.0</param>
		/// <returns>Boolean result value.</returns>
		// Token: 0x06001605 RID: 5637 RVA: 0x0008D588 File Offset: 0x0008B788
		public int CompareObj(HRegion objects2, HTuple epsilon)
		{
			IntPtr proc = HalconAPI.PreCall(588);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objects2);
			HalconAPI.Store(proc, 0, epsilon);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(epsilon);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objects2);
			return result;
		}

		/// <summary>
		///   Compare iconic objects regarding equality.
		///   Instance represents: Reference objects.
		/// </summary>
		/// <param name="objects2">Test objects.</param>
		/// <param name="epsilon">Maximum allowed difference between two gray values or  coordinates etc. Default: 0.0</param>
		/// <returns>Boolean result value.</returns>
		// Token: 0x06001606 RID: 5638 RVA: 0x0008D5EC File Offset: 0x0008B7EC
		public int CompareObj(HRegion objects2, double epsilon)
		{
			IntPtr proc = HalconAPI.PreCall(588);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objects2);
			HalconAPI.StoreD(proc, 0, epsilon);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objects2);
			return result;
		}

		/// <summary>
		///   Test whether a region is contained in another region.
		///   Instance represents: Test region.
		/// </summary>
		/// <param name="region2">Region for comparison.</param>
		/// <returns>Is Region1 contained in Region2?</returns>
		// Token: 0x06001607 RID: 5639 RVA: 0x0008D64C File Offset: 0x0008B84C
		public HTuple TestSubsetRegion(HRegion region2)
		{
			IntPtr proc = HalconAPI.PreCall(589);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, region2);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(region2);
			return result;
		}

		/// <summary>
		///   Test whether the regions of two objects are identical.
		///   Instance represents: Test regions.
		/// </summary>
		/// <param name="regions2">Comparative regions.</param>
		/// <returns>boolean result value.</returns>
		// Token: 0x06001608 RID: 5640 RVA: 0x0008D6A4 File Offset: 0x0008B8A4
		public int TestEqualRegion(HRegion regions2)
		{
			IntPtr proc = HalconAPI.PreCall(590);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, regions2);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions2);
			return result;
		}

		/// <summary>
		///   Compare image objects regarding equality.
		///   Instance represents: Test objects.
		/// </summary>
		/// <param name="objects2">Comparative objects.</param>
		/// <returns>boolean result value.</returns>
		// Token: 0x06001609 RID: 5641 RVA: 0x0008D6FC File Offset: 0x0008B8FC
		public int TestEqualObj(HRegion objects2)
		{
			IntPtr proc = HalconAPI.PreCall(591);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objects2);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objects2);
			return result;
		}

		/// <summary>
		///   Store a polygon as a "filled" region.
		///   Modified instance represents: Created region.
		/// </summary>
		/// <param name="rows">Line indices of the base points of the region contour. Default: 100</param>
		/// <param name="columns">Column indices of the base points of the region contour. Default: 100</param>
		// Token: 0x0600160A RID: 5642 RVA: 0x0008D754 File Offset: 0x0008B954
		public void GenRegionPolygonFilled(HTuple rows, HTuple columns)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(598);
			HalconAPI.Store(proc, 0, rows);
			HalconAPI.Store(proc, 1, columns);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rows);
			HalconAPI.UnpinTuple(columns);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Store a polygon as a region.
		///   Modified instance represents: Created region.
		/// </summary>
		/// <param name="rows">Line indices of the base points of the region contour. Default: 100</param>
		/// <param name="columns">Colum indices of the base points of the region contour. Default: 100</param>
		// Token: 0x0600160B RID: 5643 RVA: 0x0008D7B4 File Offset: 0x0008B9B4
		public void GenRegionPolygon(HTuple rows, HTuple columns)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(599);
			HalconAPI.Store(proc, 0, rows);
			HalconAPI.Store(proc, 1, columns);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rows);
			HalconAPI.UnpinTuple(columns);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Store individual pixels as image region.
		///   Modified instance represents: Created region.
		/// </summary>
		/// <param name="rows">Lines of the pixels in the region. Default: 100</param>
		/// <param name="columns">Columns of the pixels in the region. Default: 100</param>
		// Token: 0x0600160C RID: 5644 RVA: 0x0008D814 File Offset: 0x0008BA14
		public void GenRegionPoints(HTuple rows, HTuple columns)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(600);
			HalconAPI.Store(proc, 0, rows);
			HalconAPI.Store(proc, 1, columns);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rows);
			HalconAPI.UnpinTuple(columns);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Store individual pixels as image region.
		///   Modified instance represents: Created region.
		/// </summary>
		/// <param name="rows">Lines of the pixels in the region. Default: 100</param>
		/// <param name="columns">Columns of the pixels in the region. Default: 100</param>
		// Token: 0x0600160D RID: 5645 RVA: 0x0008D874 File Offset: 0x0008BA74
		public void GenRegionPoints(int rows, int columns)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(600);
			HalconAPI.StoreI(proc, 0, rows);
			HalconAPI.StoreI(proc, 1, columns);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create a region from a runlength coding.
		///   Modified instance represents: Created region.
		/// </summary>
		/// <param name="row">Lines of the runs. Default: 100</param>
		/// <param name="columnBegin">Columns of the starting points of the runs. Default: 50</param>
		/// <param name="columnEnd">Columns of the ending points of the runs. Default: 200</param>
		// Token: 0x0600160E RID: 5646 RVA: 0x0008D8C8 File Offset: 0x0008BAC8
		public void GenRegionRuns(HTuple row, HTuple columnBegin, HTuple columnEnd)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(601);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, columnBegin);
			HalconAPI.Store(proc, 2, columnEnd);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(columnBegin);
			HalconAPI.UnpinTuple(columnEnd);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create a region from a runlength coding.
		///   Modified instance represents: Created region.
		/// </summary>
		/// <param name="row">Lines of the runs. Default: 100</param>
		/// <param name="columnBegin">Columns of the starting points of the runs. Default: 50</param>
		/// <param name="columnEnd">Columns of the ending points of the runs. Default: 200</param>
		// Token: 0x0600160F RID: 5647 RVA: 0x0008D938 File Offset: 0x0008BB38
		public void GenRegionRuns(int row, int columnBegin, int columnEnd)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(601);
			HalconAPI.StoreI(proc, 0, row);
			HalconAPI.StoreI(proc, 1, columnBegin);
			HalconAPI.StoreI(proc, 2, columnEnd);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create a rectangle of any orientation.
		///   Modified instance represents: Created rectangle.
		/// </summary>
		/// <param name="row">Line index of the center. Default: 300.0</param>
		/// <param name="column">Column index of the center. Default: 200.0</param>
		/// <param name="phi">Angle of the first edge to the horizontal (in radians). Default: 0.0</param>
		/// <param name="length1">Half width. Default: 100.0</param>
		/// <param name="length2">Half height. Default: 20.0</param>
		// Token: 0x06001610 RID: 5648 RVA: 0x0008D994 File Offset: 0x0008BB94
		public void GenRectangle2(HTuple row, HTuple column, HTuple phi, HTuple length1, HTuple length2)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(602);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, column);
			HalconAPI.Store(proc, 2, phi);
			HalconAPI.Store(proc, 3, length1);
			HalconAPI.Store(proc, 4, length2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HalconAPI.UnpinTuple(phi);
			HalconAPI.UnpinTuple(length1);
			HalconAPI.UnpinTuple(length2);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create a rectangle of any orientation.
		///   Modified instance represents: Created rectangle.
		/// </summary>
		/// <param name="row">Line index of the center. Default: 300.0</param>
		/// <param name="column">Column index of the center. Default: 200.0</param>
		/// <param name="phi">Angle of the first edge to the horizontal (in radians). Default: 0.0</param>
		/// <param name="length1">Half width. Default: 100.0</param>
		/// <param name="length2">Half height. Default: 20.0</param>
		// Token: 0x06001611 RID: 5649 RVA: 0x0008DA24 File Offset: 0x0008BC24
		public void GenRectangle2(double row, double column, double phi, double length1, double length2)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(602);
			HalconAPI.StoreD(proc, 0, row);
			HalconAPI.StoreD(proc, 1, column);
			HalconAPI.StoreD(proc, 2, phi);
			HalconAPI.StoreD(proc, 3, length1);
			HalconAPI.StoreD(proc, 4, length2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create a rectangle parallel to the coordinate axes.
		///   Modified instance represents: Created rectangle.
		/// </summary>
		/// <param name="row1">Line of upper left corner point. Default: 30.0</param>
		/// <param name="column1">Column of upper left corner point. Default: 20.0</param>
		/// <param name="row2">Line of lower right corner point. Default: 100.0</param>
		/// <param name="column2">Column of lower right corner point. Default: 200.0</param>
		// Token: 0x06001612 RID: 5650 RVA: 0x0008DA94 File Offset: 0x0008BC94
		public void GenRectangle1(HTuple row1, HTuple column1, HTuple row2, HTuple column2)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(603);
			HalconAPI.Store(proc, 0, row1);
			HalconAPI.Store(proc, 1, column1);
			HalconAPI.Store(proc, 2, row2);
			HalconAPI.Store(proc, 3, column2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row1);
			HalconAPI.UnpinTuple(column1);
			HalconAPI.UnpinTuple(row2);
			HalconAPI.UnpinTuple(column2);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create a rectangle parallel to the coordinate axes.
		///   Modified instance represents: Created rectangle.
		/// </summary>
		/// <param name="row1">Line of upper left corner point. Default: 30.0</param>
		/// <param name="column1">Column of upper left corner point. Default: 20.0</param>
		/// <param name="row2">Line of lower right corner point. Default: 100.0</param>
		/// <param name="column2">Column of lower right corner point. Default: 200.0</param>
		// Token: 0x06001613 RID: 5651 RVA: 0x0008DB14 File Offset: 0x0008BD14
		public void GenRectangle1(double row1, double column1, double row2, double column2)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(603);
			HalconAPI.StoreD(proc, 0, row1);
			HalconAPI.StoreD(proc, 1, column1);
			HalconAPI.StoreD(proc, 2, row2);
			HalconAPI.StoreD(proc, 3, column2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create a random region.
		///   Modified instance represents: Created random region with expansion Width x Height.
		/// </summary>
		/// <param name="width">Maximum horizontal expansion of random region. Default: 128</param>
		/// <param name="height">Maximum vertical expansion of random region. Default: 128</param>
		// Token: 0x06001614 RID: 5652 RVA: 0x0008DB7C File Offset: 0x0008BD7C
		public void GenRandomRegion(int width, int height)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(604);
			HalconAPI.StoreI(proc, 0, width);
			HalconAPI.StoreI(proc, 1, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create an ellipse sector.
		///   Modified instance represents: Created ellipse(s).
		/// </summary>
		/// <param name="row">Line index of center. Default: 200.0</param>
		/// <param name="column">Column index of center. Default: 200.0</param>
		/// <param name="phi">Orientation of the longer radius (Radius1). Default: 0.0</param>
		/// <param name="radius1">Longer radius. Default: 100.0</param>
		/// <param name="radius2">Shorter radius. Default: 60.0</param>
		/// <param name="startAngle">Start angle of the sector. Default: 0.0</param>
		/// <param name="endAngle">End angle of the sector. Default: 3.14159</param>
		// Token: 0x06001615 RID: 5653 RVA: 0x0008DBD0 File Offset: 0x0008BDD0
		public void GenEllipseSector(HTuple row, HTuple column, HTuple phi, HTuple radius1, HTuple radius2, HTuple startAngle, HTuple endAngle)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(608);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, column);
			HalconAPI.Store(proc, 2, phi);
			HalconAPI.Store(proc, 3, radius1);
			HalconAPI.Store(proc, 4, radius2);
			HalconAPI.Store(proc, 5, startAngle);
			HalconAPI.Store(proc, 6, endAngle);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HalconAPI.UnpinTuple(phi);
			HalconAPI.UnpinTuple(radius1);
			HalconAPI.UnpinTuple(radius2);
			HalconAPI.UnpinTuple(startAngle);
			HalconAPI.UnpinTuple(endAngle);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create an ellipse sector.
		///   Modified instance represents: Created ellipse(s).
		/// </summary>
		/// <param name="row">Line index of center. Default: 200.0</param>
		/// <param name="column">Column index of center. Default: 200.0</param>
		/// <param name="phi">Orientation of the longer radius (Radius1). Default: 0.0</param>
		/// <param name="radius1">Longer radius. Default: 100.0</param>
		/// <param name="radius2">Shorter radius. Default: 60.0</param>
		/// <param name="startAngle">Start angle of the sector. Default: 0.0</param>
		/// <param name="endAngle">End angle of the sector. Default: 3.14159</param>
		// Token: 0x06001616 RID: 5654 RVA: 0x0008DC80 File Offset: 0x0008BE80
		public void GenEllipseSector(double row, double column, double phi, double radius1, double radius2, double startAngle, double endAngle)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(608);
			HalconAPI.StoreD(proc, 0, row);
			HalconAPI.StoreD(proc, 1, column);
			HalconAPI.StoreD(proc, 2, phi);
			HalconAPI.StoreD(proc, 3, radius1);
			HalconAPI.StoreD(proc, 4, radius2);
			HalconAPI.StoreD(proc, 5, startAngle);
			HalconAPI.StoreD(proc, 6, endAngle);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create an ellipse.
		///   Modified instance represents: Created ellipse(s).
		/// </summary>
		/// <param name="row">Line index of center. Default: 200.0</param>
		/// <param name="column">Column index of center. Default: 200.0</param>
		/// <param name="phi">Orientation of the longer radius (Radius1). Default: 0.0</param>
		/// <param name="radius1">Longer radius. Default: 100.0</param>
		/// <param name="radius2">Shorter radius. Default: 60.0</param>
		// Token: 0x06001617 RID: 5655 RVA: 0x0008DD00 File Offset: 0x0008BF00
		public void GenEllipse(HTuple row, HTuple column, HTuple phi, HTuple radius1, HTuple radius2)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(609);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, column);
			HalconAPI.Store(proc, 2, phi);
			HalconAPI.Store(proc, 3, radius1);
			HalconAPI.Store(proc, 4, radius2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HalconAPI.UnpinTuple(phi);
			HalconAPI.UnpinTuple(radius1);
			HalconAPI.UnpinTuple(radius2);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create an ellipse.
		///   Modified instance represents: Created ellipse(s).
		/// </summary>
		/// <param name="row">Line index of center. Default: 200.0</param>
		/// <param name="column">Column index of center. Default: 200.0</param>
		/// <param name="phi">Orientation of the longer radius (Radius1). Default: 0.0</param>
		/// <param name="radius1">Longer radius. Default: 100.0</param>
		/// <param name="radius2">Shorter radius. Default: 60.0</param>
		// Token: 0x06001618 RID: 5656 RVA: 0x0008DD90 File Offset: 0x0008BF90
		public void GenEllipse(double row, double column, double phi, double radius1, double radius2)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(609);
			HalconAPI.StoreD(proc, 0, row);
			HalconAPI.StoreD(proc, 1, column);
			HalconAPI.StoreD(proc, 2, phi);
			HalconAPI.StoreD(proc, 3, radius1);
			HalconAPI.StoreD(proc, 4, radius2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create a circle sector.
		///   Modified instance represents: Generated circle sector.
		/// </summary>
		/// <param name="row">Line index of center. Default: 200.0</param>
		/// <param name="column">Column index of center. Default: 200.0</param>
		/// <param name="radius">Radius of circle. Default: 100.5</param>
		/// <param name="startAngle">Start angle of the circle sector. Default: 0.0</param>
		/// <param name="endAngle">End angle of the circle sector. Default: 3.14159</param>
		// Token: 0x06001619 RID: 5657 RVA: 0x0008DE00 File Offset: 0x0008C000
		public void GenCircleSector(HTuple row, HTuple column, HTuple radius, HTuple startAngle, HTuple endAngle)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(610);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, column);
			HalconAPI.Store(proc, 2, radius);
			HalconAPI.Store(proc, 3, startAngle);
			HalconAPI.Store(proc, 4, endAngle);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HalconAPI.UnpinTuple(radius);
			HalconAPI.UnpinTuple(startAngle);
			HalconAPI.UnpinTuple(endAngle);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create a circle sector.
		///   Modified instance represents: Generated circle sector.
		/// </summary>
		/// <param name="row">Line index of center. Default: 200.0</param>
		/// <param name="column">Column index of center. Default: 200.0</param>
		/// <param name="radius">Radius of circle. Default: 100.5</param>
		/// <param name="startAngle">Start angle of the circle sector. Default: 0.0</param>
		/// <param name="endAngle">End angle of the circle sector. Default: 3.14159</param>
		// Token: 0x0600161A RID: 5658 RVA: 0x0008DE90 File Offset: 0x0008C090
		public void GenCircleSector(double row, double column, double radius, double startAngle, double endAngle)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(610);
			HalconAPI.StoreD(proc, 0, row);
			HalconAPI.StoreD(proc, 1, column);
			HalconAPI.StoreD(proc, 2, radius);
			HalconAPI.StoreD(proc, 3, startAngle);
			HalconAPI.StoreD(proc, 4, endAngle);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create a circle.
		///   Modified instance represents: Generated circle.
		/// </summary>
		/// <param name="row">Line index of center. Default: 200.0</param>
		/// <param name="column">Column index of center. Default: 200.0</param>
		/// <param name="radius">Radius of circle. Default: 100.5</param>
		// Token: 0x0600161B RID: 5659 RVA: 0x0008DF00 File Offset: 0x0008C100
		public void GenCircle(HTuple row, HTuple column, HTuple radius)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(611);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, column);
			HalconAPI.Store(proc, 2, radius);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HalconAPI.UnpinTuple(radius);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create a circle.
		///   Modified instance represents: Generated circle.
		/// </summary>
		/// <param name="row">Line index of center. Default: 200.0</param>
		/// <param name="column">Column index of center. Default: 200.0</param>
		/// <param name="radius">Radius of circle. Default: 100.5</param>
		// Token: 0x0600161C RID: 5660 RVA: 0x0008DF70 File Offset: 0x0008C170
		public void GenCircle(double row, double column, double radius)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(611);
			HalconAPI.StoreD(proc, 0, row);
			HalconAPI.StoreD(proc, 1, column);
			HalconAPI.StoreD(proc, 2, radius);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create a checkered region.
		///   Modified instance represents: Created checkerboard region.
		/// </summary>
		/// <param name="widthRegion">Largest occurring $x$ value of the region. Default: 511</param>
		/// <param name="heightRegion">Largest occurring $y$ value of the region. Default: 511</param>
		/// <param name="widthPattern">Width of a field of the checkerboard. Default: 64</param>
		/// <param name="heightPattern">Height of a field of the checkerboard. Default: 64</param>
		// Token: 0x0600161D RID: 5661 RVA: 0x0008DFCC File Offset: 0x0008C1CC
		public void GenCheckerRegion(int widthRegion, int heightRegion, int widthPattern, int heightPattern)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(612);
			HalconAPI.StoreI(proc, 0, widthRegion);
			HalconAPI.StoreI(proc, 1, heightRegion);
			HalconAPI.StoreI(proc, 2, widthPattern);
			HalconAPI.StoreI(proc, 3, heightPattern);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create a region from lines or pixels.
		///   Modified instance represents: Created lines/pixel region.
		/// </summary>
		/// <param name="rowSteps">Step width in line direction or zero. Default: 10</param>
		/// <param name="columnSteps">Step width in column direction or zero. Default: 10</param>
		/// <param name="type">Type of created pattern. Default: "lines"</param>
		/// <param name="width">Maximum width of pattern. Default: 512</param>
		/// <param name="height">Maximum height of pattern. Default: 512</param>
		// Token: 0x0600161E RID: 5662 RVA: 0x0008E034 File Offset: 0x0008C234
		public void GenGridRegion(HTuple rowSteps, HTuple columnSteps, string type, int width, int height)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(613);
			HalconAPI.Store(proc, 0, rowSteps);
			HalconAPI.Store(proc, 1, columnSteps);
			HalconAPI.StoreS(proc, 2, type);
			HalconAPI.StoreI(proc, 3, width);
			HalconAPI.StoreI(proc, 4, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rowSteps);
			HalconAPI.UnpinTuple(columnSteps);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create a region from lines or pixels.
		///   Modified instance represents: Created lines/pixel region.
		/// </summary>
		/// <param name="rowSteps">Step width in line direction or zero. Default: 10</param>
		/// <param name="columnSteps">Step width in column direction or zero. Default: 10</param>
		/// <param name="type">Type of created pattern. Default: "lines"</param>
		/// <param name="width">Maximum width of pattern. Default: 512</param>
		/// <param name="height">Maximum height of pattern. Default: 512</param>
		// Token: 0x0600161F RID: 5663 RVA: 0x0008E0B0 File Offset: 0x0008C2B0
		public void GenGridRegion(int rowSteps, int columnSteps, string type, int width, int height)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(613);
			HalconAPI.StoreI(proc, 0, rowSteps);
			HalconAPI.StoreI(proc, 1, columnSteps);
			HalconAPI.StoreS(proc, 2, type);
			HalconAPI.StoreI(proc, 3, width);
			HalconAPI.StoreI(proc, 4, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create random regions like circles, rectangles and ellipses.
		///   Modified instance represents: Created regions.
		/// </summary>
		/// <param name="type">Type of regions to be created. Default: "circle"</param>
		/// <param name="widthMin">Minimum width of the region. Default: 10.0</param>
		/// <param name="widthMax">Maximum width of the region. Default: 20.0</param>
		/// <param name="heightMin">Minimum height of the region. Default: 10.0</param>
		/// <param name="heightMax">Maximum height of the region. Default: 30.0</param>
		/// <param name="phiMin">Minimum rotation angle of the region. Default: -0.7854</param>
		/// <param name="phiMax">Maximum rotation angle of the region. Default: 0.7854</param>
		/// <param name="numRegions">Number of regions. Default: 100</param>
		/// <param name="width">Maximum horizontal expansion. Default: 512</param>
		/// <param name="height">Maximum vertical expansion. Default: 512</param>
		// Token: 0x06001620 RID: 5664 RVA: 0x0008E120 File Offset: 0x0008C320
		public void GenRandomRegions(string type, HTuple widthMin, HTuple widthMax, HTuple heightMin, HTuple heightMax, HTuple phiMin, HTuple phiMax, int numRegions, int width, int height)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(614);
			HalconAPI.StoreS(proc, 0, type);
			HalconAPI.Store(proc, 1, widthMin);
			HalconAPI.Store(proc, 2, widthMax);
			HalconAPI.Store(proc, 3, heightMin);
			HalconAPI.Store(proc, 4, heightMax);
			HalconAPI.Store(proc, 5, phiMin);
			HalconAPI.Store(proc, 6, phiMax);
			HalconAPI.StoreI(proc, 7, numRegions);
			HalconAPI.StoreI(proc, 8, width);
			HalconAPI.StoreI(proc, 9, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(widthMin);
			HalconAPI.UnpinTuple(widthMax);
			HalconAPI.UnpinTuple(heightMin);
			HalconAPI.UnpinTuple(heightMax);
			HalconAPI.UnpinTuple(phiMin);
			HalconAPI.UnpinTuple(phiMax);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create random regions like circles, rectangles and ellipses.
		///   Modified instance represents: Created regions.
		/// </summary>
		/// <param name="type">Type of regions to be created. Default: "circle"</param>
		/// <param name="widthMin">Minimum width of the region. Default: 10.0</param>
		/// <param name="widthMax">Maximum width of the region. Default: 20.0</param>
		/// <param name="heightMin">Minimum height of the region. Default: 10.0</param>
		/// <param name="heightMax">Maximum height of the region. Default: 30.0</param>
		/// <param name="phiMin">Minimum rotation angle of the region. Default: -0.7854</param>
		/// <param name="phiMax">Maximum rotation angle of the region. Default: 0.7854</param>
		/// <param name="numRegions">Number of regions. Default: 100</param>
		/// <param name="width">Maximum horizontal expansion. Default: 512</param>
		/// <param name="height">Maximum vertical expansion. Default: 512</param>
		// Token: 0x06001621 RID: 5665 RVA: 0x0008E1E4 File Offset: 0x0008C3E4
		public void GenRandomRegions(string type, double widthMin, double widthMax, double heightMin, double heightMax, double phiMin, double phiMax, int numRegions, int width, int height)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(614);
			HalconAPI.StoreS(proc, 0, type);
			HalconAPI.StoreD(proc, 1, widthMin);
			HalconAPI.StoreD(proc, 2, widthMax);
			HalconAPI.StoreD(proc, 3, heightMin);
			HalconAPI.StoreD(proc, 4, heightMax);
			HalconAPI.StoreD(proc, 5, phiMin);
			HalconAPI.StoreD(proc, 6, phiMax);
			HalconAPI.StoreI(proc, 7, numRegions);
			HalconAPI.StoreI(proc, 8, width);
			HalconAPI.StoreI(proc, 9, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Store input lines described in Hesse normal form as regions.
		///   Modified instance represents: Created regions (one for every line), clipped to maximum image format.
		/// </summary>
		/// <param name="orientation">Orientation of the normal vector in radians. Default: 0.0</param>
		/// <param name="distance">Distance from the line to the coordinate origin (0.0). Default: 200</param>
		// Token: 0x06001622 RID: 5666 RVA: 0x0008E280 File Offset: 0x0008C480
		public void GenRegionHline(HTuple orientation, HTuple distance)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(615);
			HalconAPI.Store(proc, 0, orientation);
			HalconAPI.Store(proc, 1, distance);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(orientation);
			HalconAPI.UnpinTuple(distance);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Store input lines described in Hesse normal form as regions.
		///   Modified instance represents: Created regions (one for every line), clipped to maximum image format.
		/// </summary>
		/// <param name="orientation">Orientation of the normal vector in radians. Default: 0.0</param>
		/// <param name="distance">Distance from the line to the coordinate origin (0.0). Default: 200</param>
		// Token: 0x06001623 RID: 5667 RVA: 0x0008E2E0 File Offset: 0x0008C4E0
		public void GenRegionHline(double orientation, double distance)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(615);
			HalconAPI.StoreD(proc, 0, orientation);
			HalconAPI.StoreD(proc, 1, distance);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Store input lines as regions.
		///   Modified instance represents: Created regions.
		/// </summary>
		/// <param name="beginRow">Line coordinates of the starting points of the input lines. Default: 100</param>
		/// <param name="beginCol">Column coordinates of the starting points of the input lines. Default: 50</param>
		/// <param name="endRow">Line coordinates of the ending points of the input lines. Default: 150</param>
		/// <param name="endCol">Column coordinates of the ending points of the input lines. Default: 250</param>
		// Token: 0x06001624 RID: 5668 RVA: 0x0008E334 File Offset: 0x0008C534
		public void GenRegionLine(HTuple beginRow, HTuple beginCol, HTuple endRow, HTuple endCol)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(616);
			HalconAPI.Store(proc, 0, beginRow);
			HalconAPI.Store(proc, 1, beginCol);
			HalconAPI.Store(proc, 2, endRow);
			HalconAPI.Store(proc, 3, endCol);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(beginRow);
			HalconAPI.UnpinTuple(beginCol);
			HalconAPI.UnpinTuple(endRow);
			HalconAPI.UnpinTuple(endCol);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Store input lines as regions.
		///   Modified instance represents: Created regions.
		/// </summary>
		/// <param name="beginRow">Line coordinates of the starting points of the input lines. Default: 100</param>
		/// <param name="beginCol">Column coordinates of the starting points of the input lines. Default: 50</param>
		/// <param name="endRow">Line coordinates of the ending points of the input lines. Default: 150</param>
		/// <param name="endCol">Column coordinates of the ending points of the input lines. Default: 250</param>
		// Token: 0x06001625 RID: 5669 RVA: 0x0008E3B4 File Offset: 0x0008C5B4
		public void GenRegionLine(int beginRow, int beginCol, int endRow, int endCol)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(616);
			HalconAPI.StoreI(proc, 0, beginRow);
			HalconAPI.StoreI(proc, 1, beginCol);
			HalconAPI.StoreI(proc, 2, endRow);
			HalconAPI.StoreI(proc, 3, endCol);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create an empty region.
		///   Modified instance represents: Empty region (no pixels).
		/// </summary>
		// Token: 0x06001626 RID: 5670 RVA: 0x0008E41C File Offset: 0x0008C61C
		public void GenEmptyRegion()
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(618);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Access the thickness of a region along the main axis.
		///   Instance represents: Region to be analysed.
		/// </summary>
		/// <param name="histogramm">Histogram of the thickness of the region along its main axis.</param>
		/// <returns>Thickness of the region along its main axis.</returns>
		// Token: 0x06001627 RID: 5671 RVA: 0x0008E460 File Offset: 0x0008C660
		public HTuple GetRegionThickness(out HTuple histogramm)
		{
			IntPtr proc = HalconAPI.PreCall(631);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out histogramm);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Polygon approximation of a region.
		///   Instance represents: Region to be approximated.
		/// </summary>
		/// <param name="tolerance">Maximum distance between the polygon and the edge of the region. Default: 5.0</param>
		/// <param name="rows">Line numbers of the base points of the contour.</param>
		/// <param name="columns">Column numbers of the base points of the contour.</param>
		// Token: 0x06001628 RID: 5672 RVA: 0x0008E4BC File Offset: 0x0008C6BC
		public void GetRegionPolygon(HTuple tolerance, out HTuple rows, out HTuple columns)
		{
			IntPtr proc = HalconAPI.PreCall(632);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, tolerance);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(tolerance);
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out rows);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out columns);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Polygon approximation of a region.
		///   Instance represents: Region to be approximated.
		/// </summary>
		/// <param name="tolerance">Maximum distance between the polygon and the edge of the region. Default: 5.0</param>
		/// <param name="rows">Line numbers of the base points of the contour.</param>
		/// <param name="columns">Column numbers of the base points of the contour.</param>
		// Token: 0x06001629 RID: 5673 RVA: 0x0008E524 File Offset: 0x0008C724
		public void GetRegionPolygon(double tolerance, out HTuple rows, out HTuple columns)
		{
			IntPtr proc = HalconAPI.PreCall(632);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, tolerance);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out rows);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out columns);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Access the pixels of a region.
		///   Instance represents: This region is accessed.
		/// </summary>
		/// <param name="rows">Line numbers of the pixels in the region</param>
		/// <param name="columns">Column numbers of the pixels in the region.</param>
		// Token: 0x0600162A RID: 5674 RVA: 0x0008E588 File Offset: 0x0008C788
		public void GetRegionPoints(out HTuple rows, out HTuple columns)
		{
			IntPtr proc = HalconAPI.PreCall(633);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out rows);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out columns);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Access the contour of an object.
		///   Instance represents: Output region.
		/// </summary>
		/// <param name="rows">Line numbers of the contour pixels.</param>
		/// <param name="columns">Column numbers of the contour pixels.</param>
		// Token: 0x0600162B RID: 5675 RVA: 0x0008E5E4 File Offset: 0x0008C7E4
		public void GetRegionContour(out HTuple rows, out HTuple columns)
		{
			IntPtr proc = HalconAPI.PreCall(634);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out rows);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out columns);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Access the runlength coding of a region.
		///   Instance represents: Output region.
		/// </summary>
		/// <param name="row">Line numbers of the chords.</param>
		/// <param name="columnBegin">Column numbers of the starting points of the chords.</param>
		/// <param name="columnEnd">Column numbers of the ending points of the chords.</param>
		// Token: 0x0600162C RID: 5676 RVA: 0x0008E640 File Offset: 0x0008C840
		public void GetRegionRuns(out HTuple row, out HTuple columnBegin, out HTuple columnEnd)
		{
			IntPtr proc = HalconAPI.PreCall(635);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out columnBegin);
			num = HTuple.LoadNew(proc, 2, HTupleType.INTEGER, num, out columnEnd);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Contour of an object as chain code.
		///   Instance represents: Region to be transformed.
		/// </summary>
		/// <param name="row">Line of starting point.</param>
		/// <param name="column">Column of starting point.</param>
		/// <param name="chain">Direction code of the contour (from starting point).</param>
		// Token: 0x0600162D RID: 5677 RVA: 0x0008E6B0 File Offset: 0x0008C8B0
		public void GetRegionChain(out int row, out int column, out HTuple chain)
		{
			IntPtr proc = HalconAPI.PreCall(636);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadI(proc, 0, num, out row);
			num = HalconAPI.LoadI(proc, 1, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.INTEGER, num, out chain);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Access convex hull as contour.
		///   Instance represents: Output region.
		/// </summary>
		/// <param name="rows">Line numbers of contour pixels.</param>
		/// <param name="columns">Column numbers of the contour pixels.</param>
		// Token: 0x0600162E RID: 5678 RVA: 0x0008E71C File Offset: 0x0008C91C
		public void GetRegionConvex(out HTuple rows, out HTuple columns)
		{
			IntPtr proc = HalconAPI.PreCall(637);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out rows);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out columns);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Classify a related group of characters with an OCR classifier.
		///   Instance represents: Characters to be recognized.
		/// </summary>
		/// <param name="image">Gray values of the characters.</param>
		/// <param name="OCRHandle">Handle of the OCR classifier.</param>
		/// <param name="expression">Expression describing the allowed word structure.</param>
		/// <param name="numAlternatives">Number of classes per character considered for the internal word correction. Default: 3</param>
		/// <param name="numCorrections">Maximum number of corrected characters. Default: 2</param>
		/// <param name="confidence">Confidence of the class of the characters.</param>
		/// <param name="word">Word text after classification and correction.</param>
		/// <param name="score">Measure of similarity between corrected word and uncorrected classification results.</param>
		/// <returns>Result of classifying the characters with the k-NN.</returns>
		// Token: 0x0600162F RID: 5679 RVA: 0x0008E778 File Offset: 0x0008C978
		public HTuple DoOcrWordKnn(HImage image, HOCRKnn OCRHandle, string expression, int numAlternatives, int numCorrections, out HTuple confidence, out string word, out double score)
		{
			IntPtr proc = HalconAPI.PreCall(647);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, OCRHandle);
			HalconAPI.StoreS(proc, 1, expression);
			HalconAPI.StoreI(proc, 2, numAlternatives);
			HalconAPI.StoreI(proc, 3, numCorrections);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out confidence);
			num = HalconAPI.LoadS(proc, 2, num, out word);
			num = HalconAPI.LoadD(proc, 3, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			GC.KeepAlive(OCRHandle);
			return result;
		}

		/// <summary>
		///   Classify a related group of characters with an OCR classifier.
		///   Instance represents: Characters to be recognized.
		/// </summary>
		/// <param name="image">Gray values of the characters.</param>
		/// <param name="OCRHandle">Handle of the OCR classifier.</param>
		/// <param name="expression">Expression describing the allowed word structure.</param>
		/// <param name="numAlternatives">Number of classes per character considered for the internal word correction. Default: 3</param>
		/// <param name="numCorrections">Maximum number of corrected characters. Default: 2</param>
		/// <param name="confidence">Confidence of the class of the characters.</param>
		/// <param name="word">Word text after classification and correction.</param>
		/// <param name="score">Measure of similarity between corrected word and uncorrected classification results.</param>
		/// <returns>Result of classifying the characters with the k-NN.</returns>
		// Token: 0x06001630 RID: 5680 RVA: 0x0008E830 File Offset: 0x0008CA30
		public string DoOcrWordKnn(HImage image, HOCRKnn OCRHandle, string expression, int numAlternatives, int numCorrections, out double confidence, out string word, out double score)
		{
			IntPtr proc = HalconAPI.PreCall(647);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, OCRHandle);
			HalconAPI.StoreS(proc, 1, expression);
			HalconAPI.StoreI(proc, 2, numAlternatives);
			HalconAPI.StoreI(proc, 3, numCorrections);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out confidence);
			num = HalconAPI.LoadS(proc, 2, num, out word);
			num = HalconAPI.LoadD(proc, 3, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			GC.KeepAlive(OCRHandle);
			return result;
		}

		/// <summary>
		///   Classify multiple characters with an k-NN classifier.
		///   Instance represents: Characters to be recognized.
		/// </summary>
		/// <param name="image">Gray values of the characters.</param>
		/// <param name="OCRHandle">Handle of the k-NN classifier.</param>
		/// <param name="confidence">Confidence of the class of the characters.</param>
		/// <returns>Result of classifying the characters with the k-NN.</returns>
		// Token: 0x06001631 RID: 5681 RVA: 0x0008E8E8 File Offset: 0x0008CAE8
		public HTuple DoOcrMultiClassKnn(HImage image, HOCRKnn OCRHandle, out HTuple confidence)
		{
			IntPtr proc = HalconAPI.PreCall(658);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, OCRHandle);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out confidence);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			GC.KeepAlive(OCRHandle);
			return result;
		}

		/// <summary>
		///   Classify multiple characters with an k-NN classifier.
		///   Instance represents: Characters to be recognized.
		/// </summary>
		/// <param name="image">Gray values of the characters.</param>
		/// <param name="OCRHandle">Handle of the k-NN classifier.</param>
		/// <param name="confidence">Confidence of the class of the characters.</param>
		/// <returns>Result of classifying the characters with the k-NN.</returns>
		// Token: 0x06001632 RID: 5682 RVA: 0x0008E960 File Offset: 0x0008CB60
		public string DoOcrMultiClassKnn(HImage image, HOCRKnn OCRHandle, out double confidence)
		{
			IntPtr proc = HalconAPI.PreCall(658);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, OCRHandle);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out confidence);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			GC.KeepAlive(OCRHandle);
			return result;
		}

		/// <summary>
		///   Classify a single character with an OCR classifier.
		///   Instance represents: Character to be recognized.
		/// </summary>
		/// <param name="image">Gray values of the character.</param>
		/// <param name="OCRHandle">Handle of the k-NN classifier.</param>
		/// <param name="numClasses">Number of maximal classes to determine. Default: 1</param>
		/// <param name="numNeighbors">Number of neighbors to consider. Default: 1</param>
		/// <param name="confidence">Confidence(s) of the class(es) of the character.</param>
		/// <returns>Results of classifying the character with the k-NN.</returns>
		// Token: 0x06001633 RID: 5683 RVA: 0x0008E9D8 File Offset: 0x0008CBD8
		public HTuple DoOcrSingleClassKnn(HImage image, HOCRKnn OCRHandle, HTuple numClasses, HTuple numNeighbors, out HTuple confidence)
		{
			IntPtr proc = HalconAPI.PreCall(659);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, OCRHandle);
			HalconAPI.Store(proc, 1, numClasses);
			HalconAPI.Store(proc, 2, numNeighbors);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numClasses);
			HalconAPI.UnpinTuple(numNeighbors);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out confidence);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			GC.KeepAlive(OCRHandle);
			return result;
		}

		/// <summary>
		///   Classify a single character with an OCR classifier.
		///   Instance represents: Character to be recognized.
		/// </summary>
		/// <param name="image">Gray values of the character.</param>
		/// <param name="OCRHandle">Handle of the k-NN classifier.</param>
		/// <param name="numClasses">Number of maximal classes to determine. Default: 1</param>
		/// <param name="numNeighbors">Number of neighbors to consider. Default: 1</param>
		/// <param name="confidence">Confidence(s) of the class(es) of the character.</param>
		/// <returns>Results of classifying the character with the k-NN.</returns>
		// Token: 0x06001634 RID: 5684 RVA: 0x0008EA70 File Offset: 0x0008CC70
		public string DoOcrSingleClassKnn(HImage image, HOCRKnn OCRHandle, HTuple numClasses, HTuple numNeighbors, out double confidence)
		{
			IntPtr proc = HalconAPI.PreCall(659);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, OCRHandle);
			HalconAPI.Store(proc, 1, numClasses);
			HalconAPI.Store(proc, 2, numNeighbors);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numClasses);
			HalconAPI.UnpinTuple(numNeighbors);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out confidence);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			GC.KeepAlive(OCRHandle);
			return result;
		}

		/// <summary>
		///   Classify a related group of characters with an OCR classifier.
		///   Instance represents: Characters to be recognized.
		/// </summary>
		/// <param name="image">Gray values of the characters.</param>
		/// <param name="OCRHandle">Handle of the OCR classifier.</param>
		/// <param name="expression">Expression describing the allowed word structure.</param>
		/// <param name="numAlternatives">Number of classes per character considered for the internal word correction. Default: 3</param>
		/// <param name="numCorrections">Maximum number of corrected characters. Default: 2</param>
		/// <param name="word">Word text after classification and correction.</param>
		/// <param name="score">Measure of similarity between corrected word and uncorrected classification results.</param>
		/// <returns>Result of classifying the characters with the SVM.</returns>
		// Token: 0x06001635 RID: 5685 RVA: 0x0008EB08 File Offset: 0x0008CD08
		public HTuple DoOcrWordSvm(HImage image, HOCRSvm OCRHandle, string expression, int numAlternatives, int numCorrections, out string word, out double score)
		{
			IntPtr proc = HalconAPI.PreCall(679);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, OCRHandle);
			HalconAPI.StoreS(proc, 1, expression);
			HalconAPI.StoreI(proc, 2, numAlternatives);
			HalconAPI.StoreI(proc, 3, numCorrections);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			num = HalconAPI.LoadS(proc, 1, num, out word);
			num = HalconAPI.LoadD(proc, 2, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			GC.KeepAlive(OCRHandle);
			return result;
		}

		/// <summary>
		///   Classify multiple characters with an SVM-based OCR classifier.
		///   Instance represents: Characters to be recognized.
		/// </summary>
		/// <param name="image">Gray values of the characters.</param>
		/// <param name="OCRHandle">Handle of the OCR classifier.</param>
		/// <returns>Result of classifying the characters with the SVM.</returns>
		// Token: 0x06001636 RID: 5686 RVA: 0x0008EBAC File Offset: 0x0008CDAC
		public HTuple DoOcrMultiClassSvm(HImage image, HOCRSvm OCRHandle)
		{
			IntPtr proc = HalconAPI.PreCall(680);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, OCRHandle);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			GC.KeepAlive(OCRHandle);
			return result;
		}

		/// <summary>
		///   Classify a single character with an SVM-based OCR classifier.
		///   Instance represents: Character to be recognized.
		/// </summary>
		/// <param name="image">Gray values of the character.</param>
		/// <param name="OCRHandle">Handle of the OCR classifier.</param>
		/// <param name="num">Number of best classes to determine. Default: 1</param>
		/// <returns>Result of classifying the character with the SVM.</returns>
		// Token: 0x06001637 RID: 5687 RVA: 0x0008EC10 File Offset: 0x0008CE10
		public HTuple DoOcrSingleClassSvm(HImage image, HOCRSvm OCRHandle, HTuple num)
		{
			IntPtr proc = HalconAPI.PreCall(681);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, OCRHandle);
			HalconAPI.Store(proc, 1, num);
			HalconAPI.InitOCT(proc, 0);
			int num2 = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(num);
			HTuple result;
			num2 = HTuple.LoadNew(proc, 0, num2, out result);
			HalconAPI.PostCall(proc, num2);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			GC.KeepAlive(OCRHandle);
			return result;
		}

		/// <summary>
		///   Classify a related group of characters with an OCR classifier.
		///   Instance represents: Characters to be recognized.
		/// </summary>
		/// <param name="image">Gray values of the characters.</param>
		/// <param name="OCRHandle">Handle of the OCR classifier.</param>
		/// <param name="expression">Expression describing the allowed word structure.</param>
		/// <param name="numAlternatives">Number of classes per character considered for the internal word correction. Default: 3</param>
		/// <param name="numCorrections">Maximum number of corrected characters. Default: 2</param>
		/// <param name="confidence">Confidence of the class of the characters.</param>
		/// <param name="word">Word text after classification and correction.</param>
		/// <param name="score">Measure of similarity between corrected word and uncorrected classification results.</param>
		/// <returns>Result of classifying the characters with the MLP.</returns>
		// Token: 0x06001638 RID: 5688 RVA: 0x0008EC84 File Offset: 0x0008CE84
		public HTuple DoOcrWordMlp(HImage image, HOCRMlp OCRHandle, string expression, int numAlternatives, int numCorrections, out HTuple confidence, out string word, out double score)
		{
			IntPtr proc = HalconAPI.PreCall(697);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, OCRHandle);
			HalconAPI.StoreS(proc, 1, expression);
			HalconAPI.StoreI(proc, 2, numAlternatives);
			HalconAPI.StoreI(proc, 3, numCorrections);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out confidence);
			num = HalconAPI.LoadS(proc, 2, num, out word);
			num = HalconAPI.LoadD(proc, 3, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			GC.KeepAlive(OCRHandle);
			return result;
		}

		/// <summary>
		///   Classify a related group of characters with an OCR classifier.
		///   Instance represents: Characters to be recognized.
		/// </summary>
		/// <param name="image">Gray values of the characters.</param>
		/// <param name="OCRHandle">Handle of the OCR classifier.</param>
		/// <param name="expression">Expression describing the allowed word structure.</param>
		/// <param name="numAlternatives">Number of classes per character considered for the internal word correction. Default: 3</param>
		/// <param name="numCorrections">Maximum number of corrected characters. Default: 2</param>
		/// <param name="confidence">Confidence of the class of the characters.</param>
		/// <param name="word">Word text after classification and correction.</param>
		/// <param name="score">Measure of similarity between corrected word and uncorrected classification results.</param>
		/// <returns>Result of classifying the characters with the MLP.</returns>
		// Token: 0x06001639 RID: 5689 RVA: 0x0008ED3C File Offset: 0x0008CF3C
		public string DoOcrWordMlp(HImage image, HOCRMlp OCRHandle, string expression, int numAlternatives, int numCorrections, out double confidence, out string word, out double score)
		{
			IntPtr proc = HalconAPI.PreCall(697);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, OCRHandle);
			HalconAPI.StoreS(proc, 1, expression);
			HalconAPI.StoreI(proc, 2, numAlternatives);
			HalconAPI.StoreI(proc, 3, numCorrections);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out confidence);
			num = HalconAPI.LoadS(proc, 2, num, out word);
			num = HalconAPI.LoadD(proc, 3, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			GC.KeepAlive(OCRHandle);
			return result;
		}

		/// <summary>
		///   Classify multiple characters with an OCR classifier.
		///   Instance represents: Characters to be recognized.
		/// </summary>
		/// <param name="image">Gray values of the characters.</param>
		/// <param name="OCRHandle">Handle of the OCR classifier.</param>
		/// <param name="confidence">Confidence of the class of the characters.</param>
		/// <returns>Result of classifying the characters with the MLP.</returns>
		// Token: 0x0600163A RID: 5690 RVA: 0x0008EDF4 File Offset: 0x0008CFF4
		public HTuple DoOcrMultiClassMlp(HImage image, HOCRMlp OCRHandle, out HTuple confidence)
		{
			IntPtr proc = HalconAPI.PreCall(698);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, OCRHandle);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out confidence);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			GC.KeepAlive(OCRHandle);
			return result;
		}

		/// <summary>
		///   Classify multiple characters with an OCR classifier.
		///   Instance represents: Characters to be recognized.
		/// </summary>
		/// <param name="image">Gray values of the characters.</param>
		/// <param name="OCRHandle">Handle of the OCR classifier.</param>
		/// <param name="confidence">Confidence of the class of the characters.</param>
		/// <returns>Result of classifying the characters with the MLP.</returns>
		// Token: 0x0600163B RID: 5691 RVA: 0x0008EE6C File Offset: 0x0008D06C
		public string DoOcrMultiClassMlp(HImage image, HOCRMlp OCRHandle, out double confidence)
		{
			IntPtr proc = HalconAPI.PreCall(698);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, OCRHandle);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out confidence);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			GC.KeepAlive(OCRHandle);
			return result;
		}

		/// <summary>
		///   Classify a single character with an OCR classifier.
		///   Instance represents: Character to be recognized.
		/// </summary>
		/// <param name="image">Gray values of the character.</param>
		/// <param name="OCRHandle">Handle of the OCR classifier.</param>
		/// <param name="num">Number of best classes to determine. Default: 1</param>
		/// <param name="confidence">Confidence(s) of the class(es) of the character.</param>
		/// <returns>Result of classifying the character with the MLP.</returns>
		// Token: 0x0600163C RID: 5692 RVA: 0x0008EEE4 File Offset: 0x0008D0E4
		public HTuple DoOcrSingleClassMlp(HImage image, HOCRMlp OCRHandle, HTuple num, out HTuple confidence)
		{
			IntPtr proc = HalconAPI.PreCall(699);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, OCRHandle);
			HalconAPI.Store(proc, 1, num);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num2 = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(num);
			HTuple result;
			num2 = HTuple.LoadNew(proc, 0, num2, out result);
			num2 = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num2, out confidence);
			HalconAPI.PostCall(proc, num2);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			GC.KeepAlive(OCRHandle);
			return result;
		}

		/// <summary>
		///   Classify a single character with an OCR classifier.
		///   Instance represents: Character to be recognized.
		/// </summary>
		/// <param name="image">Gray values of the character.</param>
		/// <param name="OCRHandle">Handle of the OCR classifier.</param>
		/// <param name="num">Number of best classes to determine. Default: 1</param>
		/// <param name="confidence">Confidence(s) of the class(es) of the character.</param>
		/// <returns>Result of classifying the character with the MLP.</returns>
		// Token: 0x0600163D RID: 5693 RVA: 0x0008EF6C File Offset: 0x0008D16C
		public string DoOcrSingleClassMlp(HImage image, HOCRMlp OCRHandle, HTuple num, out double confidence)
		{
			IntPtr proc = HalconAPI.PreCall(699);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, OCRHandle);
			HalconAPI.Store(proc, 1, num);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num2 = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(num);
			string result;
			num2 = HalconAPI.LoadS(proc, 0, num2, out result);
			num2 = HalconAPI.LoadD(proc, 1, num2, out confidence);
			HalconAPI.PostCall(proc, num2);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			GC.KeepAlive(OCRHandle);
			return result;
		}

		/// <summary>
		///   Classify one character.
		///   Instance represents: Character to be recognized.
		/// </summary>
		/// <param name="image">Gray values of the characters.</param>
		/// <param name="ocrHandle">ID of the OCR classifier.</param>
		/// <param name="confidences">Confidence values of the characters.</param>
		/// <returns>Classes (names) of the characters.</returns>
		// Token: 0x0600163E RID: 5694 RVA: 0x0008EFF4 File Offset: 0x0008D1F4
		public HTuple DoOcrSingle(HImage image, HOCRBox ocrHandle, out HTuple confidences)
		{
			IntPtr proc = HalconAPI.PreCall(713);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, ocrHandle);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out confidences);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			GC.KeepAlive(ocrHandle);
			return result;
		}

		/// <summary>
		///   Classify characters.
		///   Instance represents: Characters to be recognized.
		/// </summary>
		/// <param name="image">Gray values for the characters.</param>
		/// <param name="ocrHandle">ID of the OCR classifier.</param>
		/// <param name="confidence">Confidence values of the characters.</param>
		/// <returns>Class (name) of the characters.</returns>
		// Token: 0x0600163F RID: 5695 RVA: 0x0008F06C File Offset: 0x0008D26C
		public HTuple DoOcrMulti(HImage image, HOCRBox ocrHandle, out HTuple confidence)
		{
			IntPtr proc = HalconAPI.PreCall(714);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, ocrHandle);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out confidence);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			GC.KeepAlive(ocrHandle);
			return result;
		}

		/// <summary>
		///   Classify characters.
		///   Instance represents: Characters to be recognized.
		/// </summary>
		/// <param name="image">Gray values for the characters.</param>
		/// <param name="ocrHandle">ID of the OCR classifier.</param>
		/// <param name="confidence">Confidence values of the characters.</param>
		/// <returns>Class (name) of the characters.</returns>
		// Token: 0x06001640 RID: 5696 RVA: 0x0008F0E4 File Offset: 0x0008D2E4
		public string DoOcrMulti(HImage image, HOCRBox ocrHandle, out double confidence)
		{
			IntPtr proc = HalconAPI.PreCall(714);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, ocrHandle);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out confidence);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			GC.KeepAlive(ocrHandle);
			return result;
		}

		/// <summary>
		///   Train an OCR classifier by the input of regions.
		///   Instance represents: Characters to be trained.
		/// </summary>
		/// <param name="image">Gray values for the characters.</param>
		/// <param name="ocrHandle">ID of the desired OCR-classifier.</param>
		/// <param name="classVal">Class (name) of the characters. Default: "a"</param>
		/// <returns>Average confidence during a re-classification of the trained characters.</returns>
		// Token: 0x06001641 RID: 5697 RVA: 0x0008F15C File Offset: 0x0008D35C
		public double TraindOcrClassBox(HImage image, HOCRBox ocrHandle, HTuple classVal)
		{
			IntPtr proc = HalconAPI.PreCall(717);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, ocrHandle);
			HalconAPI.Store(proc, 1, classVal);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(classVal);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			GC.KeepAlive(ocrHandle);
			return result;
		}

		/// <summary>
		///   Train an OCR classifier by the input of regions.
		///   Instance represents: Characters to be trained.
		/// </summary>
		/// <param name="image">Gray values for the characters.</param>
		/// <param name="ocrHandle">ID of the desired OCR-classifier.</param>
		/// <param name="classVal">Class (name) of the characters. Default: "a"</param>
		/// <returns>Average confidence during a re-classification of the trained characters.</returns>
		// Token: 0x06001642 RID: 5698 RVA: 0x0008F1D0 File Offset: 0x0008D3D0
		public double TraindOcrClassBox(HImage image, HOCRBox ocrHandle, string classVal)
		{
			IntPtr proc = HalconAPI.PreCall(717);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, ocrHandle);
			HalconAPI.StoreS(proc, 1, classVal);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			GC.KeepAlive(ocrHandle);
			return result;
		}

		/// <summary>Protection of training data.</summary>
		/// <param name="trainingFile">Names of the training files. Default: ""</param>
		/// <param name="password">Passwords for protecting the training files.</param>
		/// <param name="trainingFileProtected">Names of the protected training files.</param>
		// Token: 0x06001643 RID: 5699 RVA: 0x0008F23C File Offset: 0x0008D43C
		public static void ProtectOcrTrainf(string trainingFile, HTuple password, string trainingFileProtected)
		{
			IntPtr proc = HalconAPI.PreCall(719);
			HalconAPI.StoreS(proc, 0, trainingFile);
			HalconAPI.Store(proc, 1, password);
			HalconAPI.StoreS(proc, 2, trainingFileProtected);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(password);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Protection of training data.</summary>
		/// <param name="trainingFile">Names of the training files. Default: ""</param>
		/// <param name="password">Passwords for protecting the training files.</param>
		/// <param name="trainingFileProtected">Names of the protected training files.</param>
		// Token: 0x06001644 RID: 5700 RVA: 0x0008F280 File Offset: 0x0008D480
		public static void ProtectOcrTrainf(string trainingFile, string password, string trainingFileProtected)
		{
			IntPtr proc = HalconAPI.PreCall(719);
			HalconAPI.StoreS(proc, 0, trainingFile);
			HalconAPI.StoreS(proc, 1, password);
			HalconAPI.StoreS(proc, 2, trainingFileProtected);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>
		///   Storing of training characters into a file.
		///   Instance represents: Characters to be trained.
		/// </summary>
		/// <param name="image">Gray values of the characters.</param>
		/// <param name="classVal">Class (name) of the characters.</param>
		/// <param name="trainingFile">Name of the training file. Default: "train_ocr"</param>
		// Token: 0x06001645 RID: 5701 RVA: 0x0008F2BC File Offset: 0x0008D4BC
		public void WriteOcrTrainf(HImage image, HTuple classVal, string trainingFile)
		{
			IntPtr proc = HalconAPI.PreCall(720);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, classVal);
			HalconAPI.StoreS(proc, 1, trainingFile);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(classVal);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
		}

		/// <summary>
		///   Storing of training characters into a file.
		///   Instance represents: Characters to be trained.
		/// </summary>
		/// <param name="image">Gray values of the characters.</param>
		/// <param name="classVal">Class (name) of the characters.</param>
		/// <param name="trainingFile">Name of the training file. Default: "train_ocr"</param>
		// Token: 0x06001646 RID: 5702 RVA: 0x0008F314 File Offset: 0x0008D514
		public void WriteOcrTrainf(HImage image, string classVal, string trainingFile)
		{
			IntPtr proc = HalconAPI.PreCall(720);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.StoreS(proc, 0, classVal);
			HalconAPI.StoreS(proc, 1, trainingFile);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
		}

		/// <summary>
		///   Sorting of regions with respect to their relative position.
		///   Instance represents: Regions to be sorted.
		/// </summary>
		/// <param name="sortMode">Kind of sorting. Default: "first_point"</param>
		/// <param name="order">Increasing or decreasing sorting order. Default: "true"</param>
		/// <param name="rowOrCol">Sorting first with respect to row, then to column. Default: "row"</param>
		/// <returns>Sorted regions.</returns>
		// Token: 0x06001647 RID: 5703 RVA: 0x0008F368 File Offset: 0x0008D568
		public HRegion SortRegion(string sortMode, string order, string rowOrCol)
		{
			IntPtr proc = HalconAPI.PreCall(723);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, sortMode);
			HalconAPI.StoreS(proc, 1, order);
			HalconAPI.StoreS(proc, 2, rowOrCol);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Test an OCR classifier.
		///   Instance represents: Characters to be tested.
		/// </summary>
		/// <param name="image">Gray values for the characters.</param>
		/// <param name="ocrHandle">ID of the desired OCR-classifier.</param>
		/// <param name="classVal">Class (name) of the characters. Default: "a"</param>
		/// <returns>Confidence for the character to belong to the class.</returns>
		// Token: 0x06001648 RID: 5704 RVA: 0x0008F3C8 File Offset: 0x0008D5C8
		public HTuple TestdOcrClassBox(HImage image, HOCRBox ocrHandle, HTuple classVal)
		{
			IntPtr proc = HalconAPI.PreCall(725);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, ocrHandle);
			HalconAPI.Store(proc, 1, classVal);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(classVal);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			GC.KeepAlive(ocrHandle);
			return result;
		}

		/// <summary>
		///   Test an OCR classifier.
		///   Instance represents: Characters to be tested.
		/// </summary>
		/// <param name="image">Gray values for the characters.</param>
		/// <param name="ocrHandle">ID of the desired OCR-classifier.</param>
		/// <param name="classVal">Class (name) of the characters. Default: "a"</param>
		/// <returns>Confidence for the character to belong to the class.</returns>
		// Token: 0x06001649 RID: 5705 RVA: 0x0008F43C File Offset: 0x0008D63C
		public double TestdOcrClassBox(HImage image, HOCRBox ocrHandle, string classVal)
		{
			IntPtr proc = HalconAPI.PreCall(725);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, ocrHandle);
			HalconAPI.StoreS(proc, 1, classVal);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			GC.KeepAlive(ocrHandle);
			return result;
		}

		/// <summary>
		///   Add characters to a training file.
		///   Instance represents: Characters to be trained.
		/// </summary>
		/// <param name="image">Gray values of the characters.</param>
		/// <param name="classVal">Class (name) of the characters.</param>
		/// <param name="trainingFile">Name of the training file. Default: "train_ocr"</param>
		// Token: 0x0600164A RID: 5706 RVA: 0x0008F4A8 File Offset: 0x0008D6A8
		public void AppendOcrTrainf(HImage image, HTuple classVal, string trainingFile)
		{
			IntPtr proc = HalconAPI.PreCall(730);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, classVal);
			HalconAPI.StoreS(proc, 1, trainingFile);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(classVal);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
		}

		/// <summary>
		///   Add characters to a training file.
		///   Instance represents: Characters to be trained.
		/// </summary>
		/// <param name="image">Gray values of the characters.</param>
		/// <param name="classVal">Class (name) of the characters.</param>
		/// <param name="trainingFile">Name of the training file. Default: "train_ocr"</param>
		// Token: 0x0600164B RID: 5707 RVA: 0x0008F500 File Offset: 0x0008D700
		public void AppendOcrTrainf(HImage image, string classVal, string trainingFile)
		{
			IntPtr proc = HalconAPI.PreCall(730);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.StoreS(proc, 0, classVal);
			HalconAPI.StoreS(proc, 1, trainingFile);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
		}

		/// <summary>
		///   Prune the branches of a region.
		///   Instance represents: Regions to be processed.
		/// </summary>
		/// <param name="length">Length of the branches to be removed. Default: 2</param>
		/// <returns>Result of the pruning operation.</returns>
		// Token: 0x0600164C RID: 5708 RVA: 0x0008F554 File Offset: 0x0008D754
		public HRegion Pruning(int length)
		{
			IntPtr proc = HalconAPI.PreCall(735);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, length);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Reduce a region to its boundary.
		///   Instance represents: Regions for which the boundary is to be computed.
		/// </summary>
		/// <param name="boundaryType">Boundary type. Default: "inner"</param>
		/// <returns>Resulting boundaries.</returns>
		// Token: 0x0600164D RID: 5709 RVA: 0x0008F5A4 File Offset: 0x0008D7A4
		public HRegion Boundary(string boundaryType)
		{
			IntPtr proc = HalconAPI.PreCall(736);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, boundaryType);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Perform a closing after an opening with multiple structuring elements.
		///   Instance represents: Regions to be processed.
		/// </summary>
		/// <param name="structElements">Structuring elements.</param>
		/// <returns>Fitted regions.</returns>
		// Token: 0x0600164E RID: 5710 RVA: 0x0008F5F4 File Offset: 0x0008D7F4
		public HRegion Fitting(HRegion structElements)
		{
			IntPtr proc = HalconAPI.PreCall(737);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, structElements);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(structElements);
			return result;
		}

		/// <summary>
		///   Generate standard structuring elements.
		///   Modified instance represents: Generated structuring elements.
		/// </summary>
		/// <param name="type">Type of structuring element to generate. Default: "noise"</param>
		/// <param name="row">Row coordinate of the reference point. Default: 1</param>
		/// <param name="column">Column coordinate of the reference point. Default: 1</param>
		// Token: 0x0600164F RID: 5711 RVA: 0x0008F64C File Offset: 0x0008D84C
		public void GenStructElements(string type, int row, int column)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(738);
			HalconAPI.StoreS(proc, 0, type);
			HalconAPI.StoreI(proc, 1, row);
			HalconAPI.StoreI(proc, 2, column);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Reflect a region about a point.
		///   Instance represents: Region to be reflected.
		/// </summary>
		/// <param name="row">Row coordinate of the reference point. Default: 0</param>
		/// <param name="column">Column coordinate of the reference point. Default: 0</param>
		/// <returns>Transposed region.</returns>
		// Token: 0x06001650 RID: 5712 RVA: 0x0008F6A8 File Offset: 0x0008D8A8
		public HRegion TransposeRegion(int row, int column)
		{
			IntPtr proc = HalconAPI.PreCall(739);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, row);
			HalconAPI.StoreI(proc, 1, column);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Remove the result of a hit-or-miss operation from a region (sequential).
		///   Instance represents: Regions to be processed.
		/// </summary>
		/// <param name="golayElement">Structuring element from the Golay alphabet. Default: "l"</param>
		/// <param name="iterations">Number of iterations. For 'f', 'f2', 'h' and 'i' the only useful value is 1. Default: 20</param>
		/// <returns>Result of the thinning operator.</returns>
		// Token: 0x06001651 RID: 5713 RVA: 0x0008F700 File Offset: 0x0008D900
		public HRegion ThinningSeq(string golayElement, HTuple iterations)
		{
			IntPtr proc = HalconAPI.PreCall(740);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, golayElement);
			HalconAPI.Store(proc, 1, iterations);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(iterations);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Remove the result of a hit-or-miss operation from a region (sequential).
		///   Instance represents: Regions to be processed.
		/// </summary>
		/// <param name="golayElement">Structuring element from the Golay alphabet. Default: "l"</param>
		/// <param name="iterations">Number of iterations. For 'f', 'f2', 'h' and 'i' the only useful value is 1. Default: 20</param>
		/// <returns>Result of the thinning operator.</returns>
		// Token: 0x06001652 RID: 5714 RVA: 0x0008F760 File Offset: 0x0008D960
		public HRegion ThinningSeq(string golayElement, int iterations)
		{
			IntPtr proc = HalconAPI.PreCall(740);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, golayElement);
			HalconAPI.StoreI(proc, 1, iterations);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Remove the result of a hit-or-miss operation from a region (using a Golay structuring element).
		///   Instance represents: Regions to be processed.
		/// </summary>
		/// <param name="golayElement">Structuring element from the Golay alphabet. Default: "h"</param>
		/// <param name="rotation">Rotation of the Golay element. Depending on the element, not all rotations are valid. Default: 0</param>
		/// <returns>Result of the thinning operator.</returns>
		// Token: 0x06001653 RID: 5715 RVA: 0x0008F7B8 File Offset: 0x0008D9B8
		public HRegion ThinningGolay(string golayElement, int rotation)
		{
			IntPtr proc = HalconAPI.PreCall(741);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, golayElement);
			HalconAPI.StoreI(proc, 1, rotation);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Remove the result of a hit-or-miss operation from a region.
		///   Instance represents: Regions to be processed.
		/// </summary>
		/// <param name="structElement1">Structuring element for the foreground.</param>
		/// <param name="structElement2">Structuring element for the background.</param>
		/// <param name="row">Row coordinate of the reference point. Default: 0</param>
		/// <param name="column">Column coordinate of the reference point. Default: 0</param>
		/// <param name="iterations">Number of iterations. Default: 1</param>
		/// <returns>Result of the thinning operator.</returns>
		// Token: 0x06001654 RID: 5716 RVA: 0x0008F810 File Offset: 0x0008DA10
		public HRegion Thinning(HRegion structElement1, HRegion structElement2, int row, int column, int iterations)
		{
			IntPtr proc = HalconAPI.PreCall(742);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, structElement1);
			HalconAPI.Store(proc, 3, structElement2);
			HalconAPI.StoreI(proc, 0, row);
			HalconAPI.StoreI(proc, 1, column);
			HalconAPI.StoreI(proc, 2, iterations);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(structElement1);
			GC.KeepAlive(structElement2);
			return result;
		}

		/// <summary>
		///   Add the result of a hit-or-miss operation to a region (sequential).
		///   Instance represents: Regions to be processed.
		/// </summary>
		/// <param name="golayElement">Structuring element from the Golay alphabet. Default: "h"</param>
		/// <param name="iterations">Number of iterations. Default: 1</param>
		/// <returns>Result of the thickening operator.</returns>
		// Token: 0x06001655 RID: 5717 RVA: 0x0008F890 File Offset: 0x0008DA90
		public HRegion ThickeningSeq(string golayElement, int iterations)
		{
			IntPtr proc = HalconAPI.PreCall(743);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, golayElement);
			HalconAPI.StoreI(proc, 1, iterations);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add the result of a hit-or-miss operation to a region (using a Golay structuring element).
		///   Instance represents: Regions to be processed.
		/// </summary>
		/// <param name="golayElement">Structuring element from the Golay alphabet. Default: "h"</param>
		/// <param name="rotation">Rotation of the Golay element. Depending on the element, not all rotations are valid. Default: 0</param>
		/// <returns>Result of the thickening operator.</returns>
		// Token: 0x06001656 RID: 5718 RVA: 0x0008F8E8 File Offset: 0x0008DAE8
		public HRegion ThickeningGolay(string golayElement, int rotation)
		{
			IntPtr proc = HalconAPI.PreCall(744);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, golayElement);
			HalconAPI.StoreI(proc, 1, rotation);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add the result of a hit-or-miss operation to a region.
		///   Instance represents: Regions to be processed.
		/// </summary>
		/// <param name="structElement1">Structuring element for the foreground.</param>
		/// <param name="structElement2">Structuring element for the background.</param>
		/// <param name="row">Row coordinate of the reference point. Default: 16</param>
		/// <param name="column">Column coordinate of the reference point. Default: 16</param>
		/// <param name="iterations">Number of iterations. Default: 1</param>
		/// <returns>Result of the thickening operator.</returns>
		// Token: 0x06001657 RID: 5719 RVA: 0x0008F940 File Offset: 0x0008DB40
		public HRegion Thickening(HRegion structElement1, HRegion structElement2, int row, int column, int iterations)
		{
			IntPtr proc = HalconAPI.PreCall(745);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, structElement1);
			HalconAPI.Store(proc, 3, structElement2);
			HalconAPI.StoreI(proc, 0, row);
			HalconAPI.StoreI(proc, 1, column);
			HalconAPI.StoreI(proc, 2, iterations);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(structElement1);
			GC.KeepAlive(structElement2);
			return result;
		}

		/// <summary>
		///   Hit-or-miss operation for regions using the Golay alphabet (sequential).
		///   Instance represents: Regions to be processed.
		/// </summary>
		/// <param name="golayElement">Structuring element from the Golay alphabet. Default: "h"</param>
		/// <returns>Result of the hit-or-miss operation.</returns>
		// Token: 0x06001658 RID: 5720 RVA: 0x0008F9C0 File Offset: 0x0008DBC0
		public HRegion HitOrMissSeq(string golayElement)
		{
			IntPtr proc = HalconAPI.PreCall(746);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, golayElement);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Hit-or-miss operation for regions using the Golay alphabet.
		///   Instance represents: Regions to be processed.
		/// </summary>
		/// <param name="golayElement">Structuring element from the Golay alphabet. Default: "h"</param>
		/// <param name="rotation">Rotation of the Golay element. Depending on the element, not all rotations are valid. Default: 0</param>
		/// <returns>Result of the hit-or-miss operation.</returns>
		// Token: 0x06001659 RID: 5721 RVA: 0x0008FA10 File Offset: 0x0008DC10
		public HRegion HitOrMissGolay(string golayElement, int rotation)
		{
			IntPtr proc = HalconAPI.PreCall(747);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, golayElement);
			HalconAPI.StoreI(proc, 1, rotation);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Hit-or-miss operation for regions.
		///   Instance represents: Regions to be processed.
		/// </summary>
		/// <param name="structElement1">Erosion mask for the input regions.</param>
		/// <param name="structElement2">Erosion mask for the complements of the input regions.</param>
		/// <param name="row">Row coordinate of the reference point. Default: 16</param>
		/// <param name="column">Column coordinate of the reference point. Default: 16</param>
		/// <returns>Result of the hit-or-miss operation.</returns>
		// Token: 0x0600165A RID: 5722 RVA: 0x0008FA68 File Offset: 0x0008DC68
		public HRegion HitOrMiss(HRegion structElement1, HRegion structElement2, int row, int column)
		{
			IntPtr proc = HalconAPI.PreCall(748);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, structElement1);
			HalconAPI.Store(proc, 3, structElement2);
			HalconAPI.StoreI(proc, 0, row);
			HalconAPI.StoreI(proc, 1, column);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(structElement1);
			GC.KeepAlive(structElement2);
			return result;
		}

		/// <summary>
		///   Generate the structuring elements of the Golay alphabet.
		///   Modified instance represents: Structuring element for the foreground.
		/// </summary>
		/// <param name="golayElement">Name of the structuring element. Default: "l"</param>
		/// <param name="rotation">Rotation of the Golay element. Depending on the element, not all rotations are valid. Default: 0</param>
		/// <param name="row">Row coordinate of the reference point. Default: 16</param>
		/// <param name="column">Column coordinate of the reference point. Default: 16</param>
		/// <returns>Structuring element for the background.</returns>
		// Token: 0x0600165B RID: 5723 RVA: 0x0008FAE0 File Offset: 0x0008DCE0
		public HRegion GolayElements(string golayElement, int rotation, int row, int column)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(749);
			HalconAPI.StoreS(proc, 0, golayElement);
			HalconAPI.StoreI(proc, 1, rotation);
			HalconAPI.StoreI(proc, 2, row);
			HalconAPI.StoreI(proc, 3, column);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HRegion result;
			num = HRegion.LoadNew(proc, 2, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Thinning of a region.
		///   Instance represents: Regions to be thinned.
		/// </summary>
		/// <param name="iterations1">Number of iterations for the sequential thinning with the element 'l' of the Golay alphabet. Default: 100</param>
		/// <param name="iterations2">Number of iterations for the sequential thinning with the element 'e' of the Golay alphabet. Default: 1</param>
		/// <returns>Result of the skiz operator.</returns>
		// Token: 0x0600165C RID: 5724 RVA: 0x0008FB5C File Offset: 0x0008DD5C
		public HRegion MorphSkiz(HTuple iterations1, HTuple iterations2)
		{
			IntPtr proc = HalconAPI.PreCall(750);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, iterations1);
			HalconAPI.Store(proc, 1, iterations2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(iterations1);
			HalconAPI.UnpinTuple(iterations2);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Thinning of a region.
		///   Instance represents: Regions to be thinned.
		/// </summary>
		/// <param name="iterations1">Number of iterations for the sequential thinning with the element 'l' of the Golay alphabet. Default: 100</param>
		/// <param name="iterations2">Number of iterations for the sequential thinning with the element 'e' of the Golay alphabet. Default: 1</param>
		/// <returns>Result of the skiz operator.</returns>
		// Token: 0x0600165D RID: 5725 RVA: 0x0008FBC0 File Offset: 0x0008DDC0
		public HRegion MorphSkiz(int iterations1, int iterations2)
		{
			IntPtr proc = HalconAPI.PreCall(750);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, iterations1);
			HalconAPI.StoreI(proc, 1, iterations2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the morphological skeleton of a region.
		///   Instance represents: Regions to be processed.
		/// </summary>
		/// <returns>Resulting morphological skeleton.</returns>
		// Token: 0x0600165E RID: 5726 RVA: 0x0008FC18 File Offset: 0x0008DE18
		public HRegion MorphSkeleton()
		{
			IntPtr proc = HalconAPI.PreCall(751);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the union of bottom_hat and top_hat.
		///   Instance represents: Regions to be processed.
		/// </summary>
		/// <param name="structElement">Structuring element (position-invariant).</param>
		/// <returns>Union of top hat and bottom hat.</returns>
		// Token: 0x0600165F RID: 5727 RVA: 0x0008FC60 File Offset: 0x0008DE60
		public HRegion MorphHat(HRegion structElement)
		{
			IntPtr proc = HalconAPI.PreCall(752);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, structElement);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(structElement);
			return result;
		}

		/// <summary>
		///   Compute the bottom hat of regions.
		///   Instance represents: Regions to be processed.
		/// </summary>
		/// <param name="structElement">Structuring element (position independent).</param>
		/// <returns>Result of the bottom hat operator.</returns>
		// Token: 0x06001660 RID: 5728 RVA: 0x0008FCB8 File Offset: 0x0008DEB8
		public HRegion BottomHat(HRegion structElement)
		{
			IntPtr proc = HalconAPI.PreCall(753);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, structElement);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(structElement);
			return result;
		}

		/// <summary>
		///   Compute the top hat of regions.
		///   Instance represents: Regions to be processed.
		/// </summary>
		/// <param name="structElement">Structuring element (position independent).</param>
		/// <returns>Result of the top hat operator.</returns>
		// Token: 0x06001661 RID: 5729 RVA: 0x0008FD10 File Offset: 0x0008DF10
		public HRegion TopHat(HRegion structElement)
		{
			IntPtr proc = HalconAPI.PreCall(754);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, structElement);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(structElement);
			return result;
		}

		/// <summary>
		///   Erode a region (using a reference point).
		///   Instance represents: Regions to be eroded.
		/// </summary>
		/// <param name="structElement">Structuring element.</param>
		/// <param name="row">Row coordinate of the reference point. Default: 0</param>
		/// <param name="column">Column coordinate of the reference point. Default: 0</param>
		/// <param name="iterations">Number of iterations. Default: 1</param>
		/// <returns>Eroded regions.</returns>
		// Token: 0x06001662 RID: 5730 RVA: 0x0008FD68 File Offset: 0x0008DF68
		public HRegion MinkowskiSub2(HRegion structElement, int row, int column, int iterations)
		{
			IntPtr proc = HalconAPI.PreCall(755);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, structElement);
			HalconAPI.StoreI(proc, 0, row);
			HalconAPI.StoreI(proc, 1, column);
			HalconAPI.StoreI(proc, 2, iterations);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(structElement);
			return result;
		}

		/// <summary>
		///   Erode a region.
		///   Instance represents: Regions to be eroded.
		/// </summary>
		/// <param name="structElement">Structuring element.</param>
		/// <param name="iterations">Number of iterations. Default: 1</param>
		/// <returns>Eroded regions.</returns>
		// Token: 0x06001663 RID: 5731 RVA: 0x0008FDD8 File Offset: 0x0008DFD8
		public HRegion MinkowskiSub1(HRegion structElement, int iterations)
		{
			IntPtr proc = HalconAPI.PreCall(756);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, structElement);
			HalconAPI.StoreI(proc, 0, iterations);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(structElement);
			return result;
		}

		/// <summary>
		///   Dilate a region (using a reference point).
		///   Instance represents: Regions to be dilated.
		/// </summary>
		/// <param name="structElement">Structuring element.</param>
		/// <param name="row">Row coordinate of the reference point.</param>
		/// <param name="column">Column coordinate of the reference point.</param>
		/// <param name="iterations">Number of iterations. Default: 1</param>
		/// <returns>Dilated regions.</returns>
		// Token: 0x06001664 RID: 5732 RVA: 0x0008FE38 File Offset: 0x0008E038
		public HRegion MinkowskiAdd2(HRegion structElement, int row, int column, int iterations)
		{
			IntPtr proc = HalconAPI.PreCall(757);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, structElement);
			HalconAPI.StoreI(proc, 0, row);
			HalconAPI.StoreI(proc, 1, column);
			HalconAPI.StoreI(proc, 2, iterations);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(structElement);
			return result;
		}

		/// <summary>
		///   Perform a Minkowski addition on a region.
		///   Instance represents: Regions to be dilated.
		/// </summary>
		/// <param name="structElement">Structuring element.</param>
		/// <param name="iterations">Number of iterations. Default: 1</param>
		/// <returns>Dilated regions.</returns>
		// Token: 0x06001665 RID: 5733 RVA: 0x0008FEA8 File Offset: 0x0008E0A8
		public HRegion MinkowskiAdd1(HRegion structElement, int iterations)
		{
			IntPtr proc = HalconAPI.PreCall(758);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, structElement);
			HalconAPI.StoreI(proc, 0, iterations);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(structElement);
			return result;
		}

		/// <summary>
		///   Close a region with a rectangular structuring element.
		///   Instance represents: Regions to be closed.
		/// </summary>
		/// <param name="width">Width of the structuring rectangle. Default: 10</param>
		/// <param name="height">Height of the structuring rectangle. Default: 10</param>
		/// <returns>Closed regions.</returns>
		// Token: 0x06001666 RID: 5734 RVA: 0x0008FF08 File Offset: 0x0008E108
		public HRegion ClosingRectangle1(int width, int height)
		{
			IntPtr proc = HalconAPI.PreCall(759);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, width);
			HalconAPI.StoreI(proc, 1, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Close a region with an element from the Golay alphabet.
		///   Instance represents: Regions to be closed.
		/// </summary>
		/// <param name="golayElement">Structuring element from the Golay alphabet. Default: "h"</param>
		/// <param name="rotation">Rotation of the Golay element. Depending on the element, not all rotations are valid. Default: 0</param>
		/// <returns>Closed regions.</returns>
		// Token: 0x06001667 RID: 5735 RVA: 0x0008FF60 File Offset: 0x0008E160
		public HRegion ClosingGolay(string golayElement, int rotation)
		{
			IntPtr proc = HalconAPI.PreCall(760);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, golayElement);
			HalconAPI.StoreI(proc, 1, rotation);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Close a region with a circular structuring element.
		///   Instance represents: Regions to be closed.
		/// </summary>
		/// <param name="radius">Radius of the circular structuring element. Default: 3.5</param>
		/// <returns>Closed regions.</returns>
		// Token: 0x06001668 RID: 5736 RVA: 0x0008FFB8 File Offset: 0x0008E1B8
		public HRegion ClosingCircle(HTuple radius)
		{
			IntPtr proc = HalconAPI.PreCall(761);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, radius);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(radius);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Close a region with a circular structuring element.
		///   Instance represents: Regions to be closed.
		/// </summary>
		/// <param name="radius">Radius of the circular structuring element. Default: 3.5</param>
		/// <returns>Closed regions.</returns>
		// Token: 0x06001669 RID: 5737 RVA: 0x00090010 File Offset: 0x0008E210
		public HRegion ClosingCircle(double radius)
		{
			IntPtr proc = HalconAPI.PreCall(761);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, radius);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Close a region.
		///   Instance represents: Regions to be closed.
		/// </summary>
		/// <param name="structElement">Structuring element (position-invariant).</param>
		/// <returns>Closed regions.</returns>
		// Token: 0x0600166A RID: 5738 RVA: 0x00090060 File Offset: 0x0008E260
		public HRegion Closing(HRegion structElement)
		{
			IntPtr proc = HalconAPI.PreCall(762);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, structElement);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(structElement);
			return result;
		}

		/// <summary>
		///   Separate overlapping regions.
		///   Instance represents: Regions to be opened.
		/// </summary>
		/// <param name="structElement">Structuring element (position-invariant).</param>
		/// <returns>Opened regions.</returns>
		// Token: 0x0600166B RID: 5739 RVA: 0x000900B8 File Offset: 0x0008E2B8
		public HRegion OpeningSeg(HRegion structElement)
		{
			IntPtr proc = HalconAPI.PreCall(763);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, structElement);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(structElement);
			return result;
		}

		/// <summary>
		///   Open a region with an element from the Golay alphabet.
		///   Instance represents: Regions to be opened.
		/// </summary>
		/// <param name="golayElement">Structuring element from the Golay alphabet. Default: "h"</param>
		/// <param name="rotation">Rotation of the Golay element. Depending on the element, not all rotations are valid. Default: 0</param>
		/// <returns>Opened regions.</returns>
		// Token: 0x0600166C RID: 5740 RVA: 0x00090110 File Offset: 0x0008E310
		public HRegion OpeningGolay(string golayElement, int rotation)
		{
			IntPtr proc = HalconAPI.PreCall(764);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, golayElement);
			HalconAPI.StoreI(proc, 1, rotation);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Open a region with a rectangular structuring element.
		///   Instance represents: Regions to be opened.
		/// </summary>
		/// <param name="width">Width of the structuring rectangle. Default: 10</param>
		/// <param name="height">Height of the structuring rectangle. Default: 10</param>
		/// <returns>Opened regions.</returns>
		// Token: 0x0600166D RID: 5741 RVA: 0x00090168 File Offset: 0x0008E368
		public HRegion OpeningRectangle1(int width, int height)
		{
			IntPtr proc = HalconAPI.PreCall(765);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, width);
			HalconAPI.StoreI(proc, 1, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Open a region with a circular structuring element.
		///   Instance represents: Regions to be opened.
		/// </summary>
		/// <param name="radius">Radius of the circular structuring element. Default: 3.5</param>
		/// <returns>Opened regions.</returns>
		// Token: 0x0600166E RID: 5742 RVA: 0x000901C0 File Offset: 0x0008E3C0
		public HRegion OpeningCircle(HTuple radius)
		{
			IntPtr proc = HalconAPI.PreCall(766);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, radius);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(radius);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Open a region with a circular structuring element.
		///   Instance represents: Regions to be opened.
		/// </summary>
		/// <param name="radius">Radius of the circular structuring element. Default: 3.5</param>
		/// <returns>Opened regions.</returns>
		// Token: 0x0600166F RID: 5743 RVA: 0x00090218 File Offset: 0x0008E418
		public HRegion OpeningCircle(double radius)
		{
			IntPtr proc = HalconAPI.PreCall(766);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, radius);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Open a region.
		///   Instance represents: Regions to be opened.
		/// </summary>
		/// <param name="structElement">Structuring element (position-invariant).</param>
		/// <returns>Opened regions.</returns>
		// Token: 0x06001670 RID: 5744 RVA: 0x00090268 File Offset: 0x0008E468
		public HRegion Opening(HRegion structElement)
		{
			IntPtr proc = HalconAPI.PreCall(767);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, structElement);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(structElement);
			return result;
		}

		/// <summary>
		///   Erode a region sequentially.
		///   Instance represents: Regions to be eroded.
		/// </summary>
		/// <param name="golayElement">Structuring element from the Golay alphabet. Default: "h"</param>
		/// <param name="iterations">Number of iterations. Default: 1</param>
		/// <returns>Eroded regions.</returns>
		// Token: 0x06001671 RID: 5745 RVA: 0x000902C0 File Offset: 0x0008E4C0
		public HRegion ErosionSeq(string golayElement, int iterations)
		{
			IntPtr proc = HalconAPI.PreCall(768);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, golayElement);
			HalconAPI.StoreI(proc, 1, iterations);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Erode a region with an element from the Golay alphabet.
		///   Instance represents: Regions to be eroded.
		/// </summary>
		/// <param name="golayElement">Structuring element from the Golay alphabet. Default: "h"</param>
		/// <param name="iterations">Number of iterations. Default: 1</param>
		/// <param name="rotation">Rotation of the Golay element. Depending on the element, not all rotations are valid. Default: 0</param>
		/// <returns>Eroded regions.</returns>
		// Token: 0x06001672 RID: 5746 RVA: 0x00090318 File Offset: 0x0008E518
		public HRegion ErosionGolay(string golayElement, int iterations, int rotation)
		{
			IntPtr proc = HalconAPI.PreCall(769);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, golayElement);
			HalconAPI.StoreI(proc, 1, iterations);
			HalconAPI.StoreI(proc, 2, rotation);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Erode a region with a rectangular structuring element.
		///   Instance represents: Regions to be eroded.
		/// </summary>
		/// <param name="width">Width of the structuring rectangle. Default: 11</param>
		/// <param name="height">Height of the structuring rectangle. Default: 11</param>
		/// <returns>Eroded regions.</returns>
		// Token: 0x06001673 RID: 5747 RVA: 0x00090378 File Offset: 0x0008E578
		public HRegion ErosionRectangle1(int width, int height)
		{
			IntPtr proc = HalconAPI.PreCall(770);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, width);
			HalconAPI.StoreI(proc, 1, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Erode a region with a circular structuring element.
		///   Instance represents: Regions to be eroded.
		/// </summary>
		/// <param name="radius">Radius of the circular structuring element. Default: 3.5</param>
		/// <returns>Eroded regions.</returns>
		// Token: 0x06001674 RID: 5748 RVA: 0x000903D0 File Offset: 0x0008E5D0
		public HRegion ErosionCircle(HTuple radius)
		{
			IntPtr proc = HalconAPI.PreCall(771);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, radius);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(radius);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Erode a region with a circular structuring element.
		///   Instance represents: Regions to be eroded.
		/// </summary>
		/// <param name="radius">Radius of the circular structuring element. Default: 3.5</param>
		/// <returns>Eroded regions.</returns>
		// Token: 0x06001675 RID: 5749 RVA: 0x00090428 File Offset: 0x0008E628
		public HRegion ErosionCircle(double radius)
		{
			IntPtr proc = HalconAPI.PreCall(771);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, radius);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Erode a region (using a reference point).
		///   Instance represents: Regions to be eroded.
		/// </summary>
		/// <param name="structElement">Structuring element.</param>
		/// <param name="row">Row coordinate of the reference point. Default: 0</param>
		/// <param name="column">Column coordinate of the reference point. Default: 0</param>
		/// <param name="iterations">Number of iterations. Default: 1</param>
		/// <returns>Eroded regions.</returns>
		// Token: 0x06001676 RID: 5750 RVA: 0x00090478 File Offset: 0x0008E678
		public HRegion Erosion2(HRegion structElement, int row, int column, int iterations)
		{
			IntPtr proc = HalconAPI.PreCall(772);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, structElement);
			HalconAPI.StoreI(proc, 0, row);
			HalconAPI.StoreI(proc, 1, column);
			HalconAPI.StoreI(proc, 2, iterations);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(structElement);
			return result;
		}

		/// <summary>
		///   Erode a region.
		///   Instance represents: Regions to be eroded.
		/// </summary>
		/// <param name="structElement">Structuring element.</param>
		/// <param name="iterations">Number of iterations. Default: 1</param>
		/// <returns>Eroded regions.</returns>
		// Token: 0x06001677 RID: 5751 RVA: 0x000904E8 File Offset: 0x0008E6E8
		public HRegion Erosion1(HRegion structElement, int iterations)
		{
			IntPtr proc = HalconAPI.PreCall(773);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, structElement);
			HalconAPI.StoreI(proc, 0, iterations);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(structElement);
			return result;
		}

		/// <summary>
		///   Dilate a region sequentially.
		///   Instance represents: Regions to be dilated.
		/// </summary>
		/// <param name="golayElement">Structuring element from the Golay alphabet. Default: "h"</param>
		/// <param name="iterations">Number of iterations. Default: 1</param>
		/// <returns>Dilated regions.</returns>
		// Token: 0x06001678 RID: 5752 RVA: 0x00090548 File Offset: 0x0008E748
		public HRegion DilationSeq(string golayElement, int iterations)
		{
			IntPtr proc = HalconAPI.PreCall(774);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, golayElement);
			HalconAPI.StoreI(proc, 1, iterations);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Dilate a region with an element from the Golay alphabet.
		///   Instance represents: Regions to be dilated.
		/// </summary>
		/// <param name="golayElement">Structuring element from the Golay alphabet. Default: "h"</param>
		/// <param name="iterations">Number of iterations. Default: 1</param>
		/// <param name="rotation">Rotation of the Golay element. Depending on the element, not all rotations are valid. Default: 0</param>
		/// <returns>Dilated regions.</returns>
		// Token: 0x06001679 RID: 5753 RVA: 0x000905A0 File Offset: 0x0008E7A0
		public HRegion DilationGolay(string golayElement, int iterations, int rotation)
		{
			IntPtr proc = HalconAPI.PreCall(775);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, golayElement);
			HalconAPI.StoreI(proc, 1, iterations);
			HalconAPI.StoreI(proc, 2, rotation);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Dilate a region with a rectangular structuring element.
		///   Instance represents: Regions to be dilated.
		/// </summary>
		/// <param name="width">Width of the structuring rectangle. Default: 11</param>
		/// <param name="height">Height of the structuring rectangle. Default: 11</param>
		/// <returns>Dilated regions.</returns>
		// Token: 0x0600167A RID: 5754 RVA: 0x00090600 File Offset: 0x0008E800
		public HRegion DilationRectangle1(int width, int height)
		{
			IntPtr proc = HalconAPI.PreCall(776);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, width);
			HalconAPI.StoreI(proc, 1, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Dilate a region with a circular structuring element.
		///   Instance represents: Regions to be dilated.
		/// </summary>
		/// <param name="radius">Radius of the circular structuring element. Default: 3.5</param>
		/// <returns>Dilated regions.</returns>
		// Token: 0x0600167B RID: 5755 RVA: 0x00090658 File Offset: 0x0008E858
		public HRegion DilationCircle(HTuple radius)
		{
			IntPtr proc = HalconAPI.PreCall(777);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, radius);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(radius);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Dilate a region with a circular structuring element.
		///   Instance represents: Regions to be dilated.
		/// </summary>
		/// <param name="radius">Radius of the circular structuring element. Default: 3.5</param>
		/// <returns>Dilated regions.</returns>
		// Token: 0x0600167C RID: 5756 RVA: 0x000906B0 File Offset: 0x0008E8B0
		public HRegion DilationCircle(double radius)
		{
			IntPtr proc = HalconAPI.PreCall(777);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, radius);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Dilate a region (using a reference point).
		///   Instance represents: Regions to be dilated.
		/// </summary>
		/// <param name="structElement">Structuring element.</param>
		/// <param name="row">Row coordinate of the reference point. Default: 0</param>
		/// <param name="column">Column coordinate of the reference point. Default: 0</param>
		/// <param name="iterations">Number of iterations. Default: 1</param>
		/// <returns>Dilated regions.</returns>
		// Token: 0x0600167D RID: 5757 RVA: 0x00090700 File Offset: 0x0008E900
		public HRegion Dilation2(HRegion structElement, int row, int column, int iterations)
		{
			IntPtr proc = HalconAPI.PreCall(778);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, structElement);
			HalconAPI.StoreI(proc, 0, row);
			HalconAPI.StoreI(proc, 1, column);
			HalconAPI.StoreI(proc, 2, iterations);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(structElement);
			return result;
		}

		/// <summary>
		///   Dilate a region.
		///   Instance represents: Regions to be dilated.
		/// </summary>
		/// <param name="structElement">Structuring element.</param>
		/// <param name="iterations">Number of iterations. Default: 1</param>
		/// <returns>Dilated regions.</returns>
		// Token: 0x0600167E RID: 5758 RVA: 0x00090770 File Offset: 0x0008E970
		public HRegion Dilation1(HRegion structElement, int iterations)
		{
			IntPtr proc = HalconAPI.PreCall(779);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, structElement);
			HalconAPI.StoreI(proc, 0, iterations);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(structElement);
			return result;
		}

		/// <summary>
		///   Add gray values to regions.
		///   Instance represents: Input regions (without pixel values).
		/// </summary>
		/// <param name="image">Input image with pixel values for regions.</param>
		/// <returns>Output image(s) with regions and pixel values (one image per input region).</returns>
		// Token: 0x0600167F RID: 5759 RVA: 0x000907D0 File Offset: 0x0008E9D0
		public HImage AddChannels(HImage image)
		{
			IntPtr proc = HalconAPI.PreCall(1144);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Centres of circles for a specific radius.
		///   Instance represents: Binary edge image in which the circles are to be detected.
		/// </summary>
		/// <param name="radius">Radius of the circle to be searched in the image. Default: 12</param>
		/// <param name="percent">Indicates the percentage (approximately) of the (ideal) circle which must be present in the edge image RegionIn. Default: 60</param>
		/// <param name="mode">The modus defines the position of the circle in question: 0 - the radius is equivalent to the outer border of the set pixels. 1 - the radius is equivalent to the centres of the circle lines' pixels. 2 - both 0 and 1 (a little more fuzzy, but more reliable in contrast to circles set slightly differently, necessitates 50  </param>
		/// <returns>Centres of those circles which are included in the edge image by Percent percent.</returns>
		// Token: 0x06001680 RID: 5760 RVA: 0x00090828 File Offset: 0x0008EA28
		public HRegion HoughCircles(HTuple radius, HTuple percent, HTuple mode)
		{
			IntPtr proc = HalconAPI.PreCall(1149);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, radius);
			HalconAPI.Store(proc, 1, percent);
			HalconAPI.Store(proc, 2, mode);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(radius);
			HalconAPI.UnpinTuple(percent);
			HalconAPI.UnpinTuple(mode);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Centres of circles for a specific radius.
		///   Instance represents: Binary edge image in which the circles are to be detected.
		/// </summary>
		/// <param name="radius">Radius of the circle to be searched in the image. Default: 12</param>
		/// <param name="percent">Indicates the percentage (approximately) of the (ideal) circle which must be present in the edge image RegionIn. Default: 60</param>
		/// <param name="mode">The modus defines the position of the circle in question: 0 - the radius is equivalent to the outer border of the set pixels. 1 - the radius is equivalent to the centres of the circle lines' pixels. 2 - both 0 and 1 (a little more fuzzy, but more reliable in contrast to circles set slightly differently, necessitates 50  </param>
		/// <returns>Centres of those circles which are included in the edge image by Percent percent.</returns>
		// Token: 0x06001681 RID: 5761 RVA: 0x0009089C File Offset: 0x0008EA9C
		public HRegion HoughCircles(int radius, int percent, int mode)
		{
			IntPtr proc = HalconAPI.PreCall(1149);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, radius);
			HalconAPI.StoreI(proc, 1, percent);
			HalconAPI.StoreI(proc, 2, mode);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Return the Hough-Transform for circles with a given radius.
		///   Instance represents: Binary edge image in which the circles are to be detected.
		/// </summary>
		/// <param name="radius">Radius of the circle to be searched in the image. Default: 12</param>
		/// <returns>Hough transform for circles with a given radius.</returns>
		// Token: 0x06001682 RID: 5762 RVA: 0x000908FC File Offset: 0x0008EAFC
		public HImage HoughCircleTrans(HTuple radius)
		{
			IntPtr proc = HalconAPI.PreCall(1150);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, radius);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(radius);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Return the Hough-Transform for circles with a given radius.
		///   Instance represents: Binary edge image in which the circles are to be detected.
		/// </summary>
		/// <param name="radius">Radius of the circle to be searched in the image. Default: 12</param>
		/// <returns>Hough transform for circles with a given radius.</returns>
		// Token: 0x06001683 RID: 5763 RVA: 0x00090954 File Offset: 0x0008EB54
		public HImage HoughCircleTrans(int radius)
		{
			IntPtr proc = HalconAPI.PreCall(1150);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, radius);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Detect lines in edge images with the help of the Hough transform and returns it in HNF.
		///   Instance represents: Binary edge image in which the lines are to be detected.
		/// </summary>
		/// <param name="angleResolution">Adjusting the resolution in the angle area. Default: 4</param>
		/// <param name="threshold">Threshold value in the Hough image. Default: 100</param>
		/// <param name="angleGap">Minimal distance of two maxima in the Hough image (direction: angle). Default: 5</param>
		/// <param name="distGap">Minimal distance of two maxima in the Hough image (direction: distance). Default: 5</param>
		/// <param name="dist">Distance of the detected lines from the origin.</param>
		/// <returns>Angles (in radians) of the detected lines' normal vectors.</returns>
		// Token: 0x06001684 RID: 5764 RVA: 0x000909A4 File Offset: 0x0008EBA4
		public HTuple HoughLines(int angleResolution, int threshold, int angleGap, int distGap, out HTuple dist)
		{
			IntPtr proc = HalconAPI.PreCall(1153);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, angleResolution);
			HalconAPI.StoreI(proc, 1, threshold);
			HalconAPI.StoreI(proc, 2, angleGap);
			HalconAPI.StoreI(proc, 3, distGap);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out dist);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Produce the Hough transform for lines within regions.
		///   Instance represents: Binary edge image in which lines are to be detected.
		/// </summary>
		/// <param name="angleResolution">Adjusting the resolution in the angle area. Default: 4</param>
		/// <returns>Hough transform for lines.</returns>
		// Token: 0x06001685 RID: 5765 RVA: 0x00090A24 File Offset: 0x0008EC24
		public HImage HoughLineTrans(int angleResolution)
		{
			IntPtr proc = HalconAPI.PreCall(1154);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, angleResolution);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Select those lines from a set of lines (in HNF) which fit best into a region.
		///   Instance represents: Region in which the lines are to be matched.
		/// </summary>
		/// <param name="angleIn">Angles (in radians) of the normal vectors of the input lines.</param>
		/// <param name="distIn">Distances of the input lines form the origin.</param>
		/// <param name="lineWidth">Widths of the lines. Default: 7</param>
		/// <param name="thresh">Threshold value for the number of line points in the region. Default: 100</param>
		/// <param name="angleOut">Angles (in radians) of the normal vectors of the selected lines.</param>
		/// <param name="distOut">Distances of the selected lines from the origin.</param>
		/// <returns>Region array containing the matched lines.</returns>
		// Token: 0x06001686 RID: 5766 RVA: 0x00090A74 File Offset: 0x0008EC74
		public HRegion SelectMatchingLines(HTuple angleIn, HTuple distIn, int lineWidth, int thresh, out HTuple angleOut, out HTuple distOut)
		{
			IntPtr proc = HalconAPI.PreCall(1155);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, angleIn);
			HalconAPI.Store(proc, 1, distIn);
			HalconAPI.StoreI(proc, 2, lineWidth);
			HalconAPI.StoreI(proc, 3, thresh);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(angleIn);
			HalconAPI.UnpinTuple(distIn);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out angleOut);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out distOut);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Select those lines from a set of lines (in HNF) which fit best into a region.
		///   Instance represents: Region in which the lines are to be matched.
		/// </summary>
		/// <param name="angleIn">Angles (in radians) of the normal vectors of the input lines.</param>
		/// <param name="distIn">Distances of the input lines form the origin.</param>
		/// <param name="lineWidth">Widths of the lines. Default: 7</param>
		/// <param name="thresh">Threshold value for the number of line points in the region. Default: 100</param>
		/// <param name="angleOut">Angles (in radians) of the normal vectors of the selected lines.</param>
		/// <param name="distOut">Distances of the selected lines from the origin.</param>
		/// <returns>Region array containing the matched lines.</returns>
		// Token: 0x06001687 RID: 5767 RVA: 0x00090B14 File Offset: 0x0008ED14
		public HRegion SelectMatchingLines(double angleIn, double distIn, int lineWidth, int thresh, out double angleOut, out double distOut)
		{
			IntPtr proc = HalconAPI.PreCall(1155);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, angleIn);
			HalconAPI.StoreD(proc, 1, distIn);
			HalconAPI.StoreI(proc, 2, lineWidth);
			HalconAPI.StoreI(proc, 3, thresh);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			num = HalconAPI.LoadD(proc, 0, num, out angleOut);
			num = HalconAPI.LoadD(proc, 1, num, out distOut);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Query the icon for region output
		///   Modified instance represents: Icon for the regions center of gravity.
		/// </summary>
		/// <param name="windowHandle">Window handle.</param>
		// Token: 0x06001688 RID: 5768 RVA: 0x00090BA4 File Offset: 0x0008EDA4
		public void GetIcon(HWindow windowHandle)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1260);
			HalconAPI.Store(proc, 0, windowHandle);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(windowHandle);
		}

		/// <summary>
		///   Icon definition for region output.
		///   Instance represents: Icon for center of gravity.
		/// </summary>
		/// <param name="windowHandle">Window handle.</param>
		// Token: 0x06001689 RID: 5769 RVA: 0x00090BF8 File Offset: 0x0008EDF8
		public void SetIcon(HWindow windowHandle)
		{
			IntPtr proc = HalconAPI.PreCall(1261);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, windowHandle);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(windowHandle);
		}

		/// <summary>
		///   Displays regions in a window.
		///   Instance represents: Regions to display.
		/// </summary>
		/// <param name="windowHandle">Window handle.</param>
		// Token: 0x0600168A RID: 5770 RVA: 0x00090C3C File Offset: 0x0008EE3C
		public void DispRegion(HWindow windowHandle)
		{
			IntPtr proc = HalconAPI.PreCall(1262);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, windowHandle);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(windowHandle);
		}

		/// <summary>
		///   Interactive movement of a region with restriction of positions.
		///   Instance represents: Regions to move.
		/// </summary>
		/// <param name="maskRegion">Points on which it is allowed for a region to move.</param>
		/// <param name="windowHandle">Window handle.</param>
		/// <param name="row">Row index of the reference point. Default: 100</param>
		/// <param name="column">Column index of the reference point. Default: 100</param>
		/// <returns>Moved regions.</returns>
		// Token: 0x0600168B RID: 5771 RVA: 0x00090C80 File Offset: 0x0008EE80
		public HRegion DragRegion3(HRegion maskRegion, HWindow windowHandle, int row, int column)
		{
			IntPtr proc = HalconAPI.PreCall(1315);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, maskRegion);
			HalconAPI.Store(proc, 0, windowHandle);
			HalconAPI.StoreI(proc, 1, row);
			HalconAPI.StoreI(proc, 2, column);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(maskRegion);
			GC.KeepAlive(windowHandle);
			return result;
		}

		/// <summary>
		///   Interactive movement of a region with fixpoint specification.
		///   Instance represents: Regions to move.
		/// </summary>
		/// <param name="windowHandle">Window handle.</param>
		/// <param name="row">Row index of the reference point. Default: 100</param>
		/// <param name="column">Column index of the reference point. Default: 100</param>
		/// <returns>Moved regions.</returns>
		// Token: 0x0600168C RID: 5772 RVA: 0x00090CF8 File Offset: 0x0008EEF8
		public HRegion DragRegion2(HWindow windowHandle, int row, int column)
		{
			IntPtr proc = HalconAPI.PreCall(1316);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, windowHandle);
			HalconAPI.StoreI(proc, 1, row);
			HalconAPI.StoreI(proc, 2, column);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(windowHandle);
			return result;
		}

		/// <summary>
		///   Interactive moving of a region.
		///   Instance represents: Regions to move.
		/// </summary>
		/// <param name="windowHandle">Window handle.</param>
		/// <returns>Moved Regions.</returns>
		// Token: 0x0600168D RID: 5773 RVA: 0x00090D60 File Offset: 0x0008EF60
		public HRegion DragRegion1(HWindow windowHandle)
		{
			IntPtr proc = HalconAPI.PreCall(1317);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, windowHandle);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(windowHandle);
			return result;
		}

		/// <summary>
		///   Interactive drawing of a closed region.
		///   Modified instance represents: Interactive created region.
		/// </summary>
		/// <param name="windowHandle">Window handle.</param>
		// Token: 0x0600168E RID: 5774 RVA: 0x00090DB8 File Offset: 0x0008EFB8
		public void DrawRegion(HWindow windowHandle)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1336);
			HalconAPI.Store(proc, 0, windowHandle);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(windowHandle);
		}

		/// <summary>
		///   Interactive drawing of a polygon row.
		///   Modified instance represents: Region, which encompasses all painted points.
		/// </summary>
		/// <param name="windowHandle">Window handle.</param>
		// Token: 0x0600168F RID: 5775 RVA: 0x00090E0C File Offset: 0x0008F00C
		public void DrawPolygon(HWindow windowHandle)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1337);
			HalconAPI.Store(proc, 0, windowHandle);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(windowHandle);
		}

		/// <summary>
		///   Calculate the distance between a line segment and one region.
		///   Instance represents: Input region.
		/// </summary>
		/// <param name="row1">Row coordinate of the first point of the line segment.</param>
		/// <param name="column1">Column coordinate of the first point of the line segment.</param>
		/// <param name="row2">Row coordinate of the second point of the line segment.</param>
		/// <param name="column2">Column coordinate of the second point of the line segment.</param>
		/// <param name="distanceMin">Minimum distance between the line segment and the region.</param>
		/// <param name="distanceMax">Maximum distance between the line segment and the region.</param>
		// Token: 0x06001690 RID: 5776 RVA: 0x00090E60 File Offset: 0x0008F060
		public void DistanceSr(HTuple row1, HTuple column1, HTuple row2, HTuple column2, out HTuple distanceMin, out HTuple distanceMax)
		{
			IntPtr proc = HalconAPI.PreCall(1367);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, row1);
			HalconAPI.Store(proc, 1, column1);
			HalconAPI.Store(proc, 2, row2);
			HalconAPI.Store(proc, 3, column2);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row1);
			HalconAPI.UnpinTuple(column1);
			HalconAPI.UnpinTuple(row2);
			HalconAPI.UnpinTuple(column2);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out distanceMin);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out distanceMax);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Calculate the distance between a line segment and one region.
		///   Instance represents: Input region.
		/// </summary>
		/// <param name="row1">Row coordinate of the first point of the line segment.</param>
		/// <param name="column1">Column coordinate of the first point of the line segment.</param>
		/// <param name="row2">Row coordinate of the second point of the line segment.</param>
		/// <param name="column2">Column coordinate of the second point of the line segment.</param>
		/// <param name="distanceMin">Minimum distance between the line segment and the region.</param>
		/// <param name="distanceMax">Maximum distance between the line segment and the region.</param>
		// Token: 0x06001691 RID: 5777 RVA: 0x00090EF8 File Offset: 0x0008F0F8
		public void DistanceSr(double row1, double column1, double row2, double column2, out double distanceMin, out double distanceMax)
		{
			IntPtr proc = HalconAPI.PreCall(1367);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, row1);
			HalconAPI.StoreD(proc, 1, column1);
			HalconAPI.StoreD(proc, 2, row2);
			HalconAPI.StoreD(proc, 3, column2);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out distanceMin);
			num = HalconAPI.LoadD(proc, 1, num, out distanceMax);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Calculate the distance between a line and a region.
		///   Instance represents: Input region.
		/// </summary>
		/// <param name="row1">Row coordinate of the first point of the line.</param>
		/// <param name="column1">Column coordinate of the first point of the line.</param>
		/// <param name="row2">Row coordinate of the second point of the line.</param>
		/// <param name="column2">Column coordinate of the second point of the line.</param>
		/// <param name="distanceMin">Minimum distance between the line and the region</param>
		/// <param name="distanceMax">Maximum distance between the line and the region</param>
		// Token: 0x06001692 RID: 5778 RVA: 0x00090F74 File Offset: 0x0008F174
		public void DistanceLr(HTuple row1, HTuple column1, HTuple row2, HTuple column2, out HTuple distanceMin, out HTuple distanceMax)
		{
			IntPtr proc = HalconAPI.PreCall(1368);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, row1);
			HalconAPI.Store(proc, 1, column1);
			HalconAPI.Store(proc, 2, row2);
			HalconAPI.Store(proc, 3, column2);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row1);
			HalconAPI.UnpinTuple(column1);
			HalconAPI.UnpinTuple(row2);
			HalconAPI.UnpinTuple(column2);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out distanceMin);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out distanceMax);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Calculate the distance between a line and a region.
		///   Instance represents: Input region.
		/// </summary>
		/// <param name="row1">Row coordinate of the first point of the line.</param>
		/// <param name="column1">Column coordinate of the first point of the line.</param>
		/// <param name="row2">Row coordinate of the second point of the line.</param>
		/// <param name="column2">Column coordinate of the second point of the line.</param>
		/// <param name="distanceMin">Minimum distance between the line and the region</param>
		/// <param name="distanceMax">Maximum distance between the line and the region</param>
		// Token: 0x06001693 RID: 5779 RVA: 0x0009100C File Offset: 0x0008F20C
		public void DistanceLr(double row1, double column1, double row2, double column2, out double distanceMin, out double distanceMax)
		{
			IntPtr proc = HalconAPI.PreCall(1368);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, row1);
			HalconAPI.StoreD(proc, 1, column1);
			HalconAPI.StoreD(proc, 2, row2);
			HalconAPI.StoreD(proc, 3, column2);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out distanceMin);
			num = HalconAPI.LoadD(proc, 1, num, out distanceMax);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Calculate the distance between a point and a region.
		///   Instance represents: Input region.
		/// </summary>
		/// <param name="row">Row coordinate of the point.</param>
		/// <param name="column">Column coordinate of the point.</param>
		/// <param name="distanceMin">Minimum distance between the point and the region.</param>
		/// <param name="distanceMax">Maximum distance between the point and the region.</param>
		// Token: 0x06001694 RID: 5780 RVA: 0x00091088 File Offset: 0x0008F288
		public void DistancePr(HTuple row, HTuple column, out HTuple distanceMin, out HTuple distanceMax)
		{
			IntPtr proc = HalconAPI.PreCall(1369);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, column);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out distanceMin);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out distanceMax);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Calculate the distance between a point and a region.
		///   Instance represents: Input region.
		/// </summary>
		/// <param name="row">Row coordinate of the point.</param>
		/// <param name="column">Column coordinate of the point.</param>
		/// <param name="distanceMin">Minimum distance between the point and the region.</param>
		/// <param name="distanceMax">Maximum distance between the point and the region.</param>
		// Token: 0x06001695 RID: 5781 RVA: 0x00091100 File Offset: 0x0008F300
		public void DistancePr(double row, double column, out double distanceMin, out double distanceMax)
		{
			IntPtr proc = HalconAPI.PreCall(1369);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, row);
			HalconAPI.StoreD(proc, 1, column);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out distanceMin);
			num = HalconAPI.LoadD(proc, 1, num, out distanceMax);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Determine the noise distribution of an image.
		///   Instance represents: Region from which the noise distribution is to be estimated.
		/// </summary>
		/// <param name="image">Corresponding image.</param>
		/// <param name="filterSize">Size of the mean filter. Default: 21</param>
		/// <returns>Noise distribution of all input regions.</returns>
		// Token: 0x06001696 RID: 5782 RVA: 0x0009116C File Offset: 0x0008F36C
		public HTuple NoiseDistributionMean(HImage image, int filterSize)
		{
			IntPtr proc = HalconAPI.PreCall(1440);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.StoreI(proc, 0, filterSize);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Determine the fuzzy entropy of regions.
		///   Instance represents: Regions for which the fuzzy entropy is to be calculated.
		/// </summary>
		/// <param name="image">Input image containing the fuzzy membership values.</param>
		/// <param name="apar">Start of the fuzzy function. Default: 0</param>
		/// <param name="cpar">End of the fuzzy function. Default: 255</param>
		/// <returns>Fuzzy entropy of a region.</returns>
		// Token: 0x06001697 RID: 5783 RVA: 0x000911CC File Offset: 0x0008F3CC
		public HTuple FuzzyEntropy(HImage image, int apar, int cpar)
		{
			IntPtr proc = HalconAPI.PreCall(1457);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.StoreI(proc, 0, apar);
			HalconAPI.StoreI(proc, 1, cpar);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Calculate the fuzzy perimeter of a region.
		///   Instance represents: Regions for which the fuzzy perimeter is to be calculated.
		/// </summary>
		/// <param name="image">Input image containing the fuzzy membership values.</param>
		/// <param name="apar">Start of the fuzzy function. Default: 0</param>
		/// <param name="cpar">End of the fuzzy function. Default: 255</param>
		/// <returns>Fuzzy perimeter of a region.</returns>
		// Token: 0x06001698 RID: 5784 RVA: 0x00091234 File Offset: 0x0008F434
		public HTuple FuzzyPerimeter(HImage image, int apar, int cpar)
		{
			IntPtr proc = HalconAPI.PreCall(1458);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.StoreI(proc, 0, apar);
			HalconAPI.StoreI(proc, 1, cpar);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Paint regions with their average gray value.
		///   Instance represents: Input regions.
		/// </summary>
		/// <param name="image">original gray-value image.</param>
		/// <returns>Result image with painted regions.</returns>
		// Token: 0x06001699 RID: 5785 RVA: 0x0009129C File Offset: 0x0008F49C
		public HImage RegionToMean(HImage image)
		{
			IntPtr proc = HalconAPI.PreCall(1476);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Close edge gaps using the edge amplitude image.
		///   Instance represents: Region containing one pixel thick edges.
		/// </summary>
		/// <param name="gradient">Edge amplitude (gradient) image.</param>
		/// <param name="minAmplitude">Minimum edge amplitude. Default: 16</param>
		/// <param name="maxGapLength">Maximal number of points by which edges are extended. Default: 3</param>
		/// <returns>Region containing closed edges.</returns>
		// Token: 0x0600169A RID: 5786 RVA: 0x000912F4 File Offset: 0x0008F4F4
		public HRegion CloseEdgesLength(HImage gradient, int minAmplitude, int maxGapLength)
		{
			IntPtr proc = HalconAPI.PreCall(1573);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, gradient);
			HalconAPI.StoreI(proc, 0, minAmplitude);
			HalconAPI.StoreI(proc, 1, maxGapLength);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(gradient);
			return result;
		}

		/// <summary>
		///   Close edge gaps using the edge amplitude image.
		///   Instance represents: Region containing one pixel thick edges.
		/// </summary>
		/// <param name="edgeImage">Edge amplitude (gradient) image.</param>
		/// <param name="minAmplitude">Minimum edge amplitude. Default: 16</param>
		/// <returns>Region containing closed edges.</returns>
		// Token: 0x0600169B RID: 5787 RVA: 0x0009135C File Offset: 0x0008F55C
		public HRegion CloseEdges(HImage edgeImage, int minAmplitude)
		{
			IntPtr proc = HalconAPI.PreCall(1574);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, edgeImage);
			HalconAPI.StoreI(proc, 0, minAmplitude);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(edgeImage);
			return result;
		}

		/// <summary>
		///   Deserialize a serialized region.
		///   Modified instance represents: Region.
		/// </summary>
		/// <param name="serializedItemHandle">Handle of the serialized item.</param>
		// Token: 0x0600169C RID: 5788 RVA: 0x000913BC File Offset: 0x0008F5BC
		public void DeserializeRegion(HSerializedItem serializedItemHandle)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1652);
			HalconAPI.Store(proc, 0, serializedItemHandle);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(serializedItemHandle);
		}

		/// <summary>
		///   Serialize a region.
		///   Instance represents: Region.
		/// </summary>
		/// <returns>Handle of the serialized item.</returns>
		// Token: 0x0600169D RID: 5789 RVA: 0x00091410 File Offset: 0x0008F610
		public HSerializedItem SerializeRegion()
		{
			IntPtr proc = HalconAPI.PreCall(1653);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HSerializedItem result;
			num = HSerializedItem.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Write regions to a file.
		///   Instance represents: Region of the images which are returned.
		/// </summary>
		/// <param name="fileName">Name of region file. Default: "region.hobj"</param>
		// Token: 0x0600169E RID: 5790 RVA: 0x00091458 File Offset: 0x0008F658
		public void WriteRegion(string fileName)
		{
			IntPtr proc = HalconAPI.PreCall(1654);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, fileName);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Read binary images or HALCON regions.
		///   Modified instance represents: Read region.
		/// </summary>
		/// <param name="fileName">Name of the region to be read.</param>
		// Token: 0x0600169F RID: 5791 RVA: 0x00091494 File Offset: 0x0008F694
		public void ReadRegion(string fileName)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1657);
			HalconAPI.StoreS(proc, 0, fileName);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Geometric moments of regions.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="PSI2">Moment of 2nd order.</param>
		/// <param name="PSI3">Moment of 2nd order.</param>
		/// <param name="PSI4">Moment of 2nd order.</param>
		/// <returns>Moment of 2nd order.</returns>
		// Token: 0x060016A0 RID: 5792 RVA: 0x000914E0 File Offset: 0x0008F6E0
		public HTuple MomentsRegionCentralInvar(out HTuple PSI2, out HTuple PSI3, out HTuple PSI4)
		{
			IntPtr proc = HalconAPI.PreCall(1694);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out PSI2);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out PSI3);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out PSI4);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Geometric moments of regions.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="PSI2">Moment of 2nd order.</param>
		/// <param name="PSI3">Moment of 2nd order.</param>
		/// <param name="PSI4">Moment of 2nd order.</param>
		/// <returns>Moment of 2nd order.</returns>
		// Token: 0x060016A1 RID: 5793 RVA: 0x00091564 File Offset: 0x0008F764
		public double MomentsRegionCentralInvar(out double PSI2, out double PSI3, out double PSI4)
		{
			IntPtr proc = HalconAPI.PreCall(1694);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out PSI2);
			num = HalconAPI.LoadD(proc, 2, num, out PSI3);
			num = HalconAPI.LoadD(proc, 3, num, out PSI4);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Geometric moments of regions.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="i2">Moment of 2nd order.</param>
		/// <param name="i3">Moment of 2nd order.</param>
		/// <param name="i4">Moment of 3rd order.</param>
		/// <returns>Moment of 2nd order.</returns>
		// Token: 0x060016A2 RID: 5794 RVA: 0x000915E4 File Offset: 0x0008F7E4
		public HTuple MomentsRegionCentral(out HTuple i2, out HTuple i3, out HTuple i4)
		{
			IntPtr proc = HalconAPI.PreCall(1695);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out i2);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out i3);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out i4);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Geometric moments of regions.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="i2">Moment of 2nd order.</param>
		/// <param name="i3">Moment of 2nd order.</param>
		/// <param name="i4">Moment of 3rd order.</param>
		/// <returns>Moment of 2nd order.</returns>
		// Token: 0x060016A3 RID: 5795 RVA: 0x00091668 File Offset: 0x0008F868
		public double MomentsRegionCentral(out double i2, out double i3, out double i4)
		{
			IntPtr proc = HalconAPI.PreCall(1695);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out i2);
			num = HalconAPI.LoadD(proc, 2, num, out i3);
			num = HalconAPI.LoadD(proc, 3, num, out i4);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Geometric moments of regions.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="m12">Moment of 3rd order (column-dependent).</param>
		/// <param name="m03">Moment of 3rd order (column-dependent).</param>
		/// <param name="m30">Moment of 3rd order (line-dependent).</param>
		/// <returns>Moment of 3rd order (line-dependent).</returns>
		// Token: 0x060016A4 RID: 5796 RVA: 0x000916E8 File Offset: 0x0008F8E8
		public HTuple MomentsRegion3rdInvar(out HTuple m12, out HTuple m03, out HTuple m30)
		{
			IntPtr proc = HalconAPI.PreCall(1696);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out m12);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out m03);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out m30);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Geometric moments of regions.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="m12">Moment of 3rd order (column-dependent).</param>
		/// <param name="m03">Moment of 3rd order (column-dependent).</param>
		/// <param name="m30">Moment of 3rd order (line-dependent).</param>
		/// <returns>Moment of 3rd order (line-dependent).</returns>
		// Token: 0x060016A5 RID: 5797 RVA: 0x0009176C File Offset: 0x0008F96C
		public double MomentsRegion3rdInvar(out double m12, out double m03, out double m30)
		{
			IntPtr proc = HalconAPI.PreCall(1696);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out m12);
			num = HalconAPI.LoadD(proc, 2, num, out m03);
			num = HalconAPI.LoadD(proc, 3, num, out m30);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Geometric moments of regions.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="m12">Moment of 3rd order (column-dependent).</param>
		/// <param name="m03">Moment of 3rd order (column-dependent).</param>
		/// <param name="m30">Moment of 3rd order (line-dependent).</param>
		/// <returns>Moment of 3rd order (line-dependent).</returns>
		// Token: 0x060016A6 RID: 5798 RVA: 0x000917EC File Offset: 0x0008F9EC
		public HTuple MomentsRegion3rd(out HTuple m12, out HTuple m03, out HTuple m30)
		{
			IntPtr proc = HalconAPI.PreCall(1697);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out m12);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out m03);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out m30);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Geometric moments of regions.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="m12">Moment of 3rd order (column-dependent).</param>
		/// <param name="m03">Moment of 3rd order (column-dependent).</param>
		/// <param name="m30">Moment of 3rd order (line-dependent).</param>
		/// <returns>Moment of 3rd order (line-dependent).</returns>
		// Token: 0x060016A7 RID: 5799 RVA: 0x00091870 File Offset: 0x0008FA70
		public double MomentsRegion3rd(out double m12, out double m03, out double m30)
		{
			IntPtr proc = HalconAPI.PreCall(1697);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out m12);
			num = HalconAPI.LoadD(proc, 2, num, out m03);
			num = HalconAPI.LoadD(proc, 3, num, out m30);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Smallest surrounding rectangle with any orientation.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="row">Line index of the center.</param>
		/// <param name="column">Column index of the center.</param>
		/// <param name="phi">Orientation of the surrounding rectangle (arc measure)</param>
		/// <param name="length1">First radius (half length) of the surrounding rectangle.</param>
		/// <param name="length2">Second radius (half width) of the surrounding rectangle.</param>
		// Token: 0x060016A8 RID: 5800 RVA: 0x000918F0 File Offset: 0x0008FAF0
		public void SmallestRectangle2(out HTuple row, out HTuple column, out HTuple phi, out HTuple length1, out HTuple length2)
		{
			IntPtr proc = HalconAPI.PreCall(1698);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out phi);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out length1);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out length2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Smallest surrounding rectangle with any orientation.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="row">Line index of the center.</param>
		/// <param name="column">Column index of the center.</param>
		/// <param name="phi">Orientation of the surrounding rectangle (arc measure)</param>
		/// <param name="length1">First radius (half length) of the surrounding rectangle.</param>
		/// <param name="length2">Second radius (half width) of the surrounding rectangle.</param>
		// Token: 0x060016A9 RID: 5801 RVA: 0x00091988 File Offset: 0x0008FB88
		public void SmallestRectangle2(out double row, out double column, out double phi, out double length1, out double length2)
		{
			IntPtr proc = HalconAPI.PreCall(1698);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out row);
			num = HalconAPI.LoadD(proc, 1, num, out column);
			num = HalconAPI.LoadD(proc, 2, num, out phi);
			num = HalconAPI.LoadD(proc, 3, num, out length1);
			num = HalconAPI.LoadD(proc, 4, num, out length2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Surrounding rectangle parallel to the coordinate axes.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="row1">Line index of upper left corner point.</param>
		/// <param name="column1">Column index of upper left corner point.</param>
		/// <param name="row2">Line index of lower right corner point.</param>
		/// <param name="column2">Column index of lower right corner point.</param>
		// Token: 0x060016AA RID: 5802 RVA: 0x00091A18 File Offset: 0x0008FC18
		public void SmallestRectangle1(out HTuple row1, out HTuple column1, out HTuple row2, out HTuple column2)
		{
			IntPtr proc = HalconAPI.PreCall(1699);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out row1);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out column1);
			num = HTuple.LoadNew(proc, 2, HTupleType.INTEGER, num, out row2);
			num = HTuple.LoadNew(proc, 3, HTupleType.INTEGER, num, out column2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Surrounding rectangle parallel to the coordinate axes.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="row1">Line index of upper left corner point.</param>
		/// <param name="column1">Column index of upper left corner point.</param>
		/// <param name="row2">Line index of lower right corner point.</param>
		/// <param name="column2">Column index of lower right corner point.</param>
		// Token: 0x060016AB RID: 5803 RVA: 0x00091A9C File Offset: 0x0008FC9C
		public void SmallestRectangle1(out int row1, out int column1, out int row2, out int column2)
		{
			IntPtr proc = HalconAPI.PreCall(1699);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadI(proc, 0, num, out row1);
			num = HalconAPI.LoadI(proc, 1, num, out column1);
			num = HalconAPI.LoadI(proc, 2, num, out row2);
			num = HalconAPI.LoadI(proc, 3, num, out column2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Smallest surrounding circle of a region.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="row">Line index of the center.</param>
		/// <param name="column">Column index of the center.</param>
		/// <param name="radius">Radius of the surrounding circle.</param>
		// Token: 0x060016AC RID: 5804 RVA: 0x00091B1C File Offset: 0x0008FD1C
		public void SmallestCircle(out HTuple row, out HTuple column, out HTuple radius)
		{
			IntPtr proc = HalconAPI.PreCall(1700);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out radius);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Smallest surrounding circle of a region.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="row">Line index of the center.</param>
		/// <param name="column">Column index of the center.</param>
		/// <param name="radius">Radius of the surrounding circle.</param>
		// Token: 0x060016AD RID: 5805 RVA: 0x00091B8C File Offset: 0x0008FD8C
		public void SmallestCircle(out double row, out double column, out double radius)
		{
			IntPtr proc = HalconAPI.PreCall(1700);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out row);
			num = HalconAPI.LoadD(proc, 1, num, out column);
			num = HalconAPI.LoadD(proc, 2, num, out radius);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Choose regions having a certain relation to each other.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="pattern">Region compared to Regions.</param>
		/// <param name="feature">Shape features to be checked. Default: "covers"</param>
		/// <param name="min">Lower border of feature. Default: 50.0</param>
		/// <param name="max">Upper border of the feature. Default: 100.0</param>
		/// <returns>Regions fulfilling the condition.</returns>
		// Token: 0x060016AE RID: 5806 RVA: 0x00091BF8 File Offset: 0x0008FDF8
		public HRegion SelectShapeProto(HRegion pattern, HTuple feature, HTuple min, HTuple max)
		{
			IntPtr proc = HalconAPI.PreCall(1701);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, pattern);
			HalconAPI.Store(proc, 0, feature);
			HalconAPI.Store(proc, 1, min);
			HalconAPI.Store(proc, 2, max);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(feature);
			HalconAPI.UnpinTuple(min);
			HalconAPI.UnpinTuple(max);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(pattern);
			return result;
		}

		/// <summary>
		///   Choose regions having a certain relation to each other.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="pattern">Region compared to Regions.</param>
		/// <param name="feature">Shape features to be checked. Default: "covers"</param>
		/// <param name="min">Lower border of feature. Default: 50.0</param>
		/// <param name="max">Upper border of the feature. Default: 100.0</param>
		/// <returns>Regions fulfilling the condition.</returns>
		// Token: 0x060016AF RID: 5807 RVA: 0x00091C7C File Offset: 0x0008FE7C
		public HRegion SelectShapeProto(HRegion pattern, string feature, double min, double max)
		{
			IntPtr proc = HalconAPI.PreCall(1701);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, pattern);
			HalconAPI.StoreS(proc, 0, feature);
			HalconAPI.StoreD(proc, 1, min);
			HalconAPI.StoreD(proc, 2, max);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(pattern);
			return result;
		}

		/// <summary>
		///   Calculate shape features of regions.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="features">Shape features to be calculated. Default: "area"</param>
		/// <returns>The calculated features.</returns>
		// Token: 0x060016B0 RID: 5808 RVA: 0x00091CEC File Offset: 0x0008FEEC
		public HTuple RegionFeatures(HTuple features)
		{
			IntPtr proc = HalconAPI.PreCall(1702);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, features);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(features);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calculate shape features of regions.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="features">Shape features to be calculated. Default: "area"</param>
		/// <returns>The calculated features.</returns>
		// Token: 0x060016B1 RID: 5809 RVA: 0x00091D44 File Offset: 0x0008FF44
		public double RegionFeatures(string features)
		{
			IntPtr proc = HalconAPI.PreCall(1702);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, features);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Choose regions with the aid of shape features.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="features">Shape features to be checked. Default: "area"</param>
		/// <param name="operation">Linkage type of the individual features. Default: "and"</param>
		/// <param name="min">Lower limits of the features or 'min'. Default: 150.0</param>
		/// <param name="max">Upper limits of the features or 'max'. Default: 99999.0</param>
		/// <returns>Regions fulfilling the condition.</returns>
		// Token: 0x060016B2 RID: 5810 RVA: 0x00091D94 File Offset: 0x0008FF94
		public HRegion SelectShape(HTuple features, string operation, HTuple min, HTuple max)
		{
			IntPtr proc = HalconAPI.PreCall(1703);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, features);
			HalconAPI.StoreS(proc, 1, operation);
			HalconAPI.Store(proc, 2, min);
			HalconAPI.Store(proc, 3, max);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(features);
			HalconAPI.UnpinTuple(min);
			HalconAPI.UnpinTuple(max);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Choose regions with the aid of shape features.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="features">Shape features to be checked. Default: "area"</param>
		/// <param name="operation">Linkage type of the individual features. Default: "and"</param>
		/// <param name="min">Lower limits of the features or 'min'. Default: 150.0</param>
		/// <param name="max">Upper limits of the features or 'max'. Default: 99999.0</param>
		/// <returns>Regions fulfilling the condition.</returns>
		// Token: 0x060016B3 RID: 5811 RVA: 0x00091E10 File Offset: 0x00090010
		public HRegion SelectShape(string features, string operation, double min, double max)
		{
			IntPtr proc = HalconAPI.PreCall(1703);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, features);
			HalconAPI.StoreS(proc, 1, operation);
			HalconAPI.StoreD(proc, 2, min);
			HalconAPI.StoreD(proc, 3, max);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Characteristic values for runlength coding of regions.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="KFactor">Storing factor in relation to a square.</param>
		/// <param name="LFactor">Mean number of runs per line.</param>
		/// <param name="meanLength">Mean length of runs.</param>
		/// <param name="bytes">Number of bytes necessary for coding the region.</param>
		/// <returns>Number of runs.</returns>
		// Token: 0x060016B4 RID: 5812 RVA: 0x00091E7C File Offset: 0x0009007C
		public HTuple RunlengthFeatures(out HTuple KFactor, out HTuple LFactor, out HTuple meanLength, out HTuple bytes)
		{
			IntPtr proc = HalconAPI.PreCall(1704);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out KFactor);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out LFactor);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out meanLength);
			num = HTuple.LoadNew(proc, 4, HTupleType.INTEGER, num, out bytes);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Characteristic values for runlength coding of regions.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="KFactor">Storing factor in relation to a square.</param>
		/// <param name="LFactor">Mean number of runs per line.</param>
		/// <param name="meanLength">Mean length of runs.</param>
		/// <param name="bytes">Number of bytes necessary for coding the region.</param>
		/// <returns>Number of runs.</returns>
		// Token: 0x060016B5 RID: 5813 RVA: 0x00091F14 File Offset: 0x00090114
		public int RunlengthFeatures(out double KFactor, out double LFactor, out double meanLength, out int bytes)
		{
			IntPtr proc = HalconAPI.PreCall(1704);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out KFactor);
			num = HalconAPI.LoadD(proc, 2, num, out LFactor);
			num = HalconAPI.LoadD(proc, 3, num, out meanLength);
			num = HalconAPI.LoadI(proc, 4, num, out bytes);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Search direct neighbors.
		///   Instance represents: Starting regions.
		/// </summary>
		/// <param name="regions2">Comparative regions.</param>
		/// <param name="maxDistance">Maximal distance of regions. Default: 1</param>
		/// <param name="regionIndex2">Indices of the found regions from Regions2.</param>
		/// <returns>Indices of the found regions from Regions1.</returns>
		// Token: 0x060016B6 RID: 5814 RVA: 0x00091FA8 File Offset: 0x000901A8
		public HTuple FindNeighbors(HRegion regions2, int maxDistance, out HTuple regionIndex2)
		{
			IntPtr proc = HalconAPI.PreCall(1705);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, regions2);
			HalconAPI.StoreI(proc, 0, maxDistance);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out regionIndex2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions2);
			return result;
		}

		/// <summary>
		///   Geometric moments of regions.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="PHI2">Moment of 2nd order.</param>
		/// <returns>Moment of 2nd order.</returns>
		// Token: 0x060016B7 RID: 5815 RVA: 0x0009201C File Offset: 0x0009021C
		public HTuple MomentsRegion2ndRelInvar(out HTuple PHI2)
		{
			IntPtr proc = HalconAPI.PreCall(1706);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out PHI2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Geometric moments of regions.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="PHI2">Moment of 2nd order.</param>
		/// <returns>Moment of 2nd order.</returns>
		// Token: 0x060016B8 RID: 5816 RVA: 0x00092078 File Offset: 0x00090278
		public double MomentsRegion2ndRelInvar(out double PHI2)
		{
			IntPtr proc = HalconAPI.PreCall(1706);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out PHI2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Geometric moments of regions.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="m20">Moment of 2nd order (line-dependent).</param>
		/// <param name="m02">Moment of 2nd order (column-dependent).</param>
		/// <returns>Product of inertia of the axes through the center parallel to the coordinate axes.</returns>
		// Token: 0x060016B9 RID: 5817 RVA: 0x000920D4 File Offset: 0x000902D4
		public HTuple MomentsRegion2ndInvar(out HTuple m20, out HTuple m02)
		{
			IntPtr proc = HalconAPI.PreCall(1707);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out m20);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out m02);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Geometric moments of regions.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="m20">Moment of 2nd order (line-dependent).</param>
		/// <param name="m02">Moment of 2nd order (column-dependent).</param>
		/// <returns>Product of inertia of the axes through the center parallel to the coordinate axes.</returns>
		// Token: 0x060016BA RID: 5818 RVA: 0x00092144 File Offset: 0x00090344
		public double MomentsRegion2ndInvar(out double m20, out double m02)
		{
			IntPtr proc = HalconAPI.PreCall(1707);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out m20);
			num = HalconAPI.LoadD(proc, 2, num, out m02);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calculate the geometric moments of regions.
		///   Instance represents: Input regions.
		/// </summary>
		/// <param name="m20">Moment of 2nd order (row-dependent).</param>
		/// <param name="m02">Moment of 2nd order (column-dependent).</param>
		/// <param name="ia">Length of the major axis of the input region.</param>
		/// <param name="ib">Length of the minor axis of the input region.</param>
		/// <returns>Product of inertia of the axes through the center parallel to the coordinate axes.</returns>
		// Token: 0x060016BB RID: 5819 RVA: 0x000921B0 File Offset: 0x000903B0
		public HTuple MomentsRegion2nd(out HTuple m20, out HTuple m02, out HTuple ia, out HTuple ib)
		{
			IntPtr proc = HalconAPI.PreCall(1708);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out m20);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out m02);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out ia);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out ib);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calculate the geometric moments of regions.
		///   Instance represents: Input regions.
		/// </summary>
		/// <param name="m20">Moment of 2nd order (row-dependent).</param>
		/// <param name="m02">Moment of 2nd order (column-dependent).</param>
		/// <param name="ia">Length of the major axis of the input region.</param>
		/// <param name="ib">Length of the minor axis of the input region.</param>
		/// <returns>Product of inertia of the axes through the center parallel to the coordinate axes.</returns>
		// Token: 0x060016BC RID: 5820 RVA: 0x00092248 File Offset: 0x00090448
		public double MomentsRegion2nd(out double m20, out double m02, out double ia, out double ib)
		{
			IntPtr proc = HalconAPI.PreCall(1708);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out m20);
			num = HalconAPI.LoadD(proc, 2, num, out m02);
			num = HalconAPI.LoadD(proc, 3, num, out ia);
			num = HalconAPI.LoadD(proc, 4, num, out ib);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Minimum distance between the contour pixels of two regions each.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="regions2">Regions to be examined.</param>
		/// <param name="row1">Line index on contour in Regions1.</param>
		/// <param name="column1">Column index on contour in Regions1.</param>
		/// <param name="row2">Line index on contour in Regions2.</param>
		/// <param name="column2">Column index on contour in Regions2.</param>
		/// <returns>Minimum distance between contours of the regions.</returns>
		// Token: 0x060016BD RID: 5821 RVA: 0x000922DC File Offset: 0x000904DC
		public HTuple DistanceRrMin(HRegion regions2, out HTuple row1, out HTuple column1, out HTuple row2, out HTuple column2)
		{
			IntPtr proc = HalconAPI.PreCall(1709);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, regions2);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out row1);
			num = HTuple.LoadNew(proc, 2, HTupleType.INTEGER, num, out column1);
			num = HTuple.LoadNew(proc, 3, HTupleType.INTEGER, num, out row2);
			num = HTuple.LoadNew(proc, 4, HTupleType.INTEGER, num, out column2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions2);
			return result;
		}

		/// <summary>
		///   Minimum distance between the contour pixels of two regions each.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="regions2">Regions to be examined.</param>
		/// <param name="row1">Line index on contour in Regions1.</param>
		/// <param name="column1">Column index on contour in Regions1.</param>
		/// <param name="row2">Line index on contour in Regions2.</param>
		/// <param name="column2">Column index on contour in Regions2.</param>
		/// <returns>Minimum distance between contours of the regions.</returns>
		// Token: 0x060016BE RID: 5822 RVA: 0x00092384 File Offset: 0x00090584
		public double DistanceRrMin(HRegion regions2, out int row1, out int column1, out int row2, out int column2)
		{
			IntPtr proc = HalconAPI.PreCall(1709);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, regions2);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadI(proc, 1, num, out row1);
			num = HalconAPI.LoadI(proc, 2, num, out column1);
			num = HalconAPI.LoadI(proc, 3, num, out row2);
			num = HalconAPI.LoadI(proc, 4, num, out column2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions2);
			return result;
		}

		/// <summary>
		///   Minimum distance between two regions with the help of dilation.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="regions2">Regions to be examined.</param>
		/// <returns>Minimum distances of the regions.</returns>
		// Token: 0x060016BF RID: 5823 RVA: 0x00092424 File Offset: 0x00090624
		public HTuple DistanceRrMinDil(HRegion regions2)
		{
			IntPtr proc = HalconAPI.PreCall(1710);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, regions2);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions2);
			return result;
		}

		/// <summary>
		///   Maximal distance between two boundary points of a region.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="row1">Row index of the first extreme point.</param>
		/// <param name="column1">Column index of the first extreme point.</param>
		/// <param name="row2">Row index of the second extreme point.</param>
		/// <param name="column2">Column index of the second extreme point.</param>
		/// <param name="diameter">Distance of the two extreme points.</param>
		// Token: 0x060016C0 RID: 5824 RVA: 0x0009247C File Offset: 0x0009067C
		public void DiameterRegion(out HTuple row1, out HTuple column1, out HTuple row2, out HTuple column2, out HTuple diameter)
		{
			IntPtr proc = HalconAPI.PreCall(1711);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out row1);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out column1);
			num = HTuple.LoadNew(proc, 2, HTupleType.INTEGER, num, out row2);
			num = HTuple.LoadNew(proc, 3, HTupleType.INTEGER, num, out column2);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out diameter);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Maximal distance between two boundary points of a region.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="row1">Row index of the first extreme point.</param>
		/// <param name="column1">Column index of the first extreme point.</param>
		/// <param name="row2">Row index of the second extreme point.</param>
		/// <param name="column2">Column index of the second extreme point.</param>
		/// <param name="diameter">Distance of the two extreme points.</param>
		// Token: 0x060016C1 RID: 5825 RVA: 0x00092514 File Offset: 0x00090714
		public void DiameterRegion(out int row1, out int column1, out int row2, out int column2, out double diameter)
		{
			IntPtr proc = HalconAPI.PreCall(1711);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadI(proc, 0, num, out row1);
			num = HalconAPI.LoadI(proc, 1, num, out column1);
			num = HalconAPI.LoadI(proc, 2, num, out row2);
			num = HalconAPI.LoadI(proc, 3, num, out column2);
			num = HalconAPI.LoadD(proc, 4, num, out diameter);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Test if the region contains a given point.
		///   Instance represents: Region(s) to be examined.
		/// </summary>
		/// <param name="row">Row index of the test pixel(s). Default: 100</param>
		/// <param name="column">Column index of the test pixel(s). Default: 100</param>
		/// <returns>Boolean result value.</returns>
		// Token: 0x060016C2 RID: 5826 RVA: 0x000925A4 File Offset: 0x000907A4
		public int TestRegionPoint(HTuple row, HTuple column)
		{
			IntPtr proc = HalconAPI.PreCall(1712);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, column);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Test if the region contains a given point.
		///   Instance represents: Region(s) to be examined.
		/// </summary>
		/// <param name="row">Row index of the test pixel(s). Default: 100</param>
		/// <param name="column">Column index of the test pixel(s). Default: 100</param>
		/// <returns>Boolean result value.</returns>
		// Token: 0x060016C3 RID: 5827 RVA: 0x00092608 File Offset: 0x00090808
		public int TestRegionPoint(int row, int column)
		{
			IntPtr proc = HalconAPI.PreCall(1712);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, row);
			HalconAPI.StoreI(proc, 1, column);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Index of all regions containing a given pixel.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="row">Line index of the test pixel. Default: 100</param>
		/// <param name="column">Column index of the test pixel. Default: 100</param>
		/// <returns>Index of the regions containing the test pixel.</returns>
		// Token: 0x060016C4 RID: 5828 RVA: 0x00092660 File Offset: 0x00090860
		public HTuple GetRegionIndex(int row, int column)
		{
			IntPtr proc = HalconAPI.PreCall(1713);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, row);
			HalconAPI.StoreI(proc, 1, column);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Choose all regions containing a given pixel.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="row">Line index of the test pixel. Default: 100</param>
		/// <param name="column">Column index of the test pixel. Default: 100</param>
		/// <returns>All regions containing the test pixel.</returns>
		// Token: 0x060016C5 RID: 5829 RVA: 0x000926BC File Offset: 0x000908BC
		public HRegion SelectRegionPoint(int row, int column)
		{
			IntPtr proc = HalconAPI.PreCall(1714);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, row);
			HalconAPI.StoreI(proc, 1, column);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Select regions of a given shape.
		///   Instance represents: Input regions to be selected.
		/// </summary>
		/// <param name="shape">Shape features to be checked. Default: "max_area"</param>
		/// <param name="percent">Similarity measure. Default: 70.0</param>
		/// <returns>Regions with desired shape.</returns>
		// Token: 0x060016C6 RID: 5830 RVA: 0x00092714 File Offset: 0x00090914
		public HRegion SelectShapeStd(string shape, double percent)
		{
			IntPtr proc = HalconAPI.PreCall(1715);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, shape);
			HalconAPI.StoreD(proc, 1, percent);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Hamming distance between two regions using normalization.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="regions2">Comparative regions.</param>
		/// <param name="norm">Type of normalization. Default: "center"</param>
		/// <param name="similarity">Similarity of two regions.</param>
		/// <returns>Hamming distance of two regions.</returns>
		// Token: 0x060016C7 RID: 5831 RVA: 0x0009276C File Offset: 0x0009096C
		public HTuple HammingDistanceNorm(HRegion regions2, HTuple norm, out HTuple similarity)
		{
			IntPtr proc = HalconAPI.PreCall(1716);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, regions2);
			HalconAPI.Store(proc, 0, norm);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(norm);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out similarity);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions2);
			return result;
		}

		/// <summary>
		///   Hamming distance between two regions using normalization.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="regions2">Comparative regions.</param>
		/// <param name="norm">Type of normalization. Default: "center"</param>
		/// <param name="similarity">Similarity of two regions.</param>
		/// <returns>Hamming distance of two regions.</returns>
		// Token: 0x060016C8 RID: 5832 RVA: 0x000927E4 File Offset: 0x000909E4
		public int HammingDistanceNorm(HRegion regions2, string norm, out double similarity)
		{
			IntPtr proc = HalconAPI.PreCall(1716);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, regions2);
			HalconAPI.StoreS(proc, 0, norm);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out similarity);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions2);
			return result;
		}

		/// <summary>
		///   Hamming distance between two regions.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="regions2">Comparative regions.</param>
		/// <param name="similarity">Similarity of two regions.</param>
		/// <returns>Hamming distance of two regions.</returns>
		// Token: 0x060016C9 RID: 5833 RVA: 0x00092854 File Offset: 0x00090A54
		public HTuple HammingDistance(HRegion regions2, out HTuple similarity)
		{
			IntPtr proc = HalconAPI.PreCall(1717);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, regions2);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out similarity);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions2);
			return result;
		}

		/// <summary>
		///   Hamming distance between two regions.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="regions2">Comparative regions.</param>
		/// <param name="similarity">Similarity of two regions.</param>
		/// <returns>Hamming distance of two regions.</returns>
		// Token: 0x060016CA RID: 5834 RVA: 0x000928C0 File Offset: 0x00090AC0
		public int HammingDistance(HRegion regions2, out double similarity)
		{
			IntPtr proc = HalconAPI.PreCall(1717);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, regions2);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out similarity);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions2);
			return result;
		}

		/// <summary>
		///   Shape features derived from the ellipse parameters.
		///   Instance represents: Region(s) to be examined.
		/// </summary>
		/// <param name="bulkiness">Calculated shape feature.</param>
		/// <param name="structureFactor">Calculated shape feature.</param>
		/// <returns>Shape feature (in case of a circle = 1.0).</returns>
		// Token: 0x060016CB RID: 5835 RVA: 0x00092928 File Offset: 0x00090B28
		public HTuple Eccentricity(out HTuple bulkiness, out HTuple structureFactor)
		{
			IntPtr proc = HalconAPI.PreCall(1718);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out bulkiness);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out structureFactor);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Shape features derived from the ellipse parameters.
		///   Instance represents: Region(s) to be examined.
		/// </summary>
		/// <param name="bulkiness">Calculated shape feature.</param>
		/// <param name="structureFactor">Calculated shape feature.</param>
		/// <returns>Shape feature (in case of a circle = 1.0).</returns>
		// Token: 0x060016CC RID: 5836 RVA: 0x00092998 File Offset: 0x00090B98
		public double Eccentricity(out double bulkiness, out double structureFactor)
		{
			IntPtr proc = HalconAPI.PreCall(1718);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out bulkiness);
			num = HalconAPI.LoadD(proc, 2, num, out structureFactor);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calculate the Euler number.
		///   Instance represents: Region(s) to be examined.
		/// </summary>
		/// <returns>Calculated Euler number.</returns>
		// Token: 0x060016CD RID: 5837 RVA: 0x00092A04 File Offset: 0x00090C04
		public HTuple EulerNumber()
		{
			IntPtr proc = HalconAPI.PreCall(1719);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Orientation of a region.
		///   Instance represents: Region(s) to be examined.
		/// </summary>
		/// <returns>Orientation of region (arc measure).</returns>
		// Token: 0x060016CE RID: 5838 RVA: 0x00092A50 File Offset: 0x00090C50
		public HTuple OrientationRegion()
		{
			IntPtr proc = HalconAPI.PreCall(1720);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calculate the parameters of the equivalent ellipse.
		///   Instance represents: Input regions.
		/// </summary>
		/// <param name="rb">Secondary radius (normalized to the area).</param>
		/// <param name="phi">Angle between main radius and x-axis in radians.</param>
		/// <returns>Main radius (normalized to the area).</returns>
		// Token: 0x060016CF RID: 5839 RVA: 0x00092A9C File Offset: 0x00090C9C
		public HTuple EllipticAxis(out HTuple rb, out HTuple phi)
		{
			IntPtr proc = HalconAPI.PreCall(1721);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out rb);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out phi);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calculate the parameters of the equivalent ellipse.
		///   Instance represents: Input regions.
		/// </summary>
		/// <param name="rb">Secondary radius (normalized to the area).</param>
		/// <param name="phi">Angle between main radius and x-axis in radians.</param>
		/// <returns>Main radius (normalized to the area).</returns>
		// Token: 0x060016D0 RID: 5840 RVA: 0x00092B0C File Offset: 0x00090D0C
		public double EllipticAxis(out double rb, out double phi)
		{
			IntPtr proc = HalconAPI.PreCall(1721);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out rb);
			num = HalconAPI.LoadD(proc, 2, num, out phi);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Pose relation of regions.
		///   Instance represents: Starting regions
		/// </summary>
		/// <param name="regions2">Comparative regions</param>
		/// <param name="direction">Desired neighboring relation. Default: "left"</param>
		/// <param name="regionIndex2">Indices in the input tuples (Regions1 or ParRef{Regions2}), respectively.</param>
		/// <returns>Indices in the input tuples (Regions1 or ParRef{Regions2}), respectively.</returns>
		// Token: 0x060016D1 RID: 5841 RVA: 0x00092B78 File Offset: 0x00090D78
		public HTuple SelectRegionSpatial(HRegion regions2, string direction, out HTuple regionIndex2)
		{
			IntPtr proc = HalconAPI.PreCall(1722);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, regions2);
			HalconAPI.StoreS(proc, 0, direction);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out regionIndex2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions2);
			return result;
		}

		/// <summary>
		///   Pose relation of regions with regard to 
		///   Instance represents: Starting regions.
		/// </summary>
		/// <param name="regions2">Comparative regions.</param>
		/// <param name="percent">Percentage of the area of the comparative region which must be located left/right or  Default: 50</param>
		/// <param name="regionIndex2">Indices of the regions in the tuple of the input regions which fulfill the pose relation.</param>
		/// <param name="relation1">Horizontal pose relation in which RegionIndex2[n] stands with RegionIndex1[n].</param>
		/// <param name="relation2">Vertical pose relation in which RegionIndex2[n] stands with RegionIndex1[n].</param>
		/// <returns>Indices of the regions in the tuple of the input regions which fulfill the pose relation.</returns>
		// Token: 0x060016D2 RID: 5842 RVA: 0x00092BEC File Offset: 0x00090DEC
		public HTuple SpatialRelation(HRegion regions2, int percent, out HTuple regionIndex2, out HTuple relation1, out HTuple relation2)
		{
			IntPtr proc = HalconAPI.PreCall(1723);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, regions2);
			HalconAPI.StoreI(proc, 0, percent);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out regionIndex2);
			num = HTuple.LoadNew(proc, 2, num, out relation1);
			num = HTuple.LoadNew(proc, 3, num, out relation2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions2);
			return result;
		}

		/// <summary>
		///   Shape factor for the convexity of a region.
		///   Instance represents: Region(s) to be examined.
		/// </summary>
		/// <returns>Convexity of the input region(s).</returns>
		// Token: 0x060016D3 RID: 5843 RVA: 0x00092C84 File Offset: 0x00090E84
		public HTuple Convexity()
		{
			IntPtr proc = HalconAPI.PreCall(1724);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Contour length of a region.
		///   Instance represents: Region(s) to be examined.
		/// </summary>
		/// <returns>Contour length of the input region(s).</returns>
		// Token: 0x060016D4 RID: 5844 RVA: 0x00092CD0 File Offset: 0x00090ED0
		public HTuple Contlength()
		{
			IntPtr proc = HalconAPI.PreCall(1725);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Number of connection components and holes
		///   Instance represents: Region(s) to be examined.
		/// </summary>
		/// <param name="numHoles">Number of holes of a region.</param>
		/// <returns>Number of connection components of a region.</returns>
		// Token: 0x060016D5 RID: 5845 RVA: 0x00092D1C File Offset: 0x00090F1C
		public HTuple ConnectAndHoles(out HTuple numHoles)
		{
			IntPtr proc = HalconAPI.PreCall(1726);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out numHoles);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Number of connection components and holes
		///   Instance represents: Region(s) to be examined.
		/// </summary>
		/// <param name="numHoles">Number of holes of a region.</param>
		/// <returns>Number of connection components of a region.</returns>
		// Token: 0x060016D6 RID: 5846 RVA: 0x00092D78 File Offset: 0x00090F78
		public int ConnectAndHoles(out int numHoles)
		{
			IntPtr proc = HalconAPI.PreCall(1726);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			num = HalconAPI.LoadI(proc, 1, num, out numHoles);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Shape factor for the rectangularity of a region.
		///   Instance represents: Region(s) to be examined.
		/// </summary>
		/// <returns>Rectangularity of the input region(s).</returns>
		// Token: 0x060016D7 RID: 5847 RVA: 0x00092DD4 File Offset: 0x00090FD4
		public HTuple Rectangularity()
		{
			IntPtr proc = HalconAPI.PreCall(1727);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Shape factor for the compactness of a region.
		///   Instance represents: Region(s) to be examined.
		/// </summary>
		/// <returns>Compactness of the input region(s).</returns>
		// Token: 0x060016D8 RID: 5848 RVA: 0x00092E20 File Offset: 0x00091020
		public HTuple Compactness()
		{
			IntPtr proc = HalconAPI.PreCall(1728);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Shape factor for the circularity (similarity to a circle) of a region.
		///   Instance represents: Region(s) to be examined.
		/// </summary>
		/// <returns>Circularity of the input region(s).</returns>
		// Token: 0x060016D9 RID: 5849 RVA: 0x00092E6C File Offset: 0x0009106C
		public HTuple Circularity()
		{
			IntPtr proc = HalconAPI.PreCall(1729);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the area of holes of regions.
		///   Instance represents: Region(s) to be examined.
		/// </summary>
		/// <returns>Area(s) of holes of the region(s).</returns>
		// Token: 0x060016DA RID: 5850 RVA: 0x00092EB8 File Offset: 0x000910B8
		public HTuple AreaHoles()
		{
			IntPtr proc = HalconAPI.PreCall(1730);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Area and center of regions.
		///   Instance represents: Region(s) to be examined.
		/// </summary>
		/// <param name="row">Line index of the center.</param>
		/// <param name="column">Column index of the center.</param>
		/// <returns>Area of the region.</returns>
		// Token: 0x060016DB RID: 5851 RVA: 0x00092F04 File Offset: 0x00091104
		public HTuple AreaCenter(out HTuple row, out HTuple column)
		{
			IntPtr proc = HalconAPI.PreCall(1731);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out column);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Area and center of regions.
		///   Instance represents: Region(s) to be examined.
		/// </summary>
		/// <param name="row">Line index of the center.</param>
		/// <param name="column">Column index of the center.</param>
		/// <returns>Area of the region.</returns>
		// Token: 0x060016DC RID: 5852 RVA: 0x00092F74 File Offset: 0x00091174
		public int AreaCenter(out double row, out double column)
		{
			IntPtr proc = HalconAPI.PreCall(1731);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out row);
			num = HalconAPI.LoadD(proc, 2, num, out column);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Distribution of runs needed for runlength encoding of a region.
		///   Instance represents: Region to be examined.
		/// </summary>
		/// <param name="background">Length distribution of the background.</param>
		/// <returns>Length distribution of the region (foreground).</returns>
		// Token: 0x060016DD RID: 5853 RVA: 0x00092FE0 File Offset: 0x000911E0
		public HTuple RunlengthDistribution(out HTuple background)
		{
			IntPtr proc = HalconAPI.PreCall(1732);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out background);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Shape factors from contour.
		///   Instance represents: Region(s) to be examined.
		/// </summary>
		/// <param name="sigma">Standard deviation of Distance.</param>
		/// <param name="roundness">Shape factor for roundness.</param>
		/// <param name="sides">Number of polygon sides.</param>
		/// <returns>Mean distance from the center.</returns>
		// Token: 0x060016DE RID: 5854 RVA: 0x0009303C File Offset: 0x0009123C
		public HTuple Roundness(out HTuple sigma, out HTuple roundness, out HTuple sides)
		{
			IntPtr proc = HalconAPI.PreCall(1733);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out sigma);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out roundness);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out sides);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Shape factors from contour.
		///   Instance represents: Region(s) to be examined.
		/// </summary>
		/// <param name="sigma">Standard deviation of Distance.</param>
		/// <param name="roundness">Shape factor for roundness.</param>
		/// <param name="sides">Number of polygon sides.</param>
		/// <returns>Mean distance from the center.</returns>
		// Token: 0x060016DF RID: 5855 RVA: 0x000930C0 File Offset: 0x000912C0
		public double Roundness(out double sigma, out double roundness, out double sides)
		{
			IntPtr proc = HalconAPI.PreCall(1733);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out sigma);
			num = HalconAPI.LoadD(proc, 2, num, out roundness);
			num = HalconAPI.LoadD(proc, 3, num, out sides);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Largest inner rectangle of a region.
		///   Instance represents: Region to be examined.
		/// </summary>
		/// <param name="row1">Row coordinate of the upper left corner point.</param>
		/// <param name="column1">Column coordinate of the upper left corner point.</param>
		/// <param name="row2">Row coordinate of the lower right corner point.</param>
		/// <param name="column2">Column coordinate of the lower right corner point.</param>
		// Token: 0x060016E0 RID: 5856 RVA: 0x00093140 File Offset: 0x00091340
		public void InnerRectangle1(out HTuple row1, out HTuple column1, out HTuple row2, out HTuple column2)
		{
			IntPtr proc = HalconAPI.PreCall(1734);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out row1);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out column1);
			num = HTuple.LoadNew(proc, 2, HTupleType.INTEGER, num, out row2);
			num = HTuple.LoadNew(proc, 3, HTupleType.INTEGER, num, out column2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Largest inner rectangle of a region.
		///   Instance represents: Region to be examined.
		/// </summary>
		/// <param name="row1">Row coordinate of the upper left corner point.</param>
		/// <param name="column1">Column coordinate of the upper left corner point.</param>
		/// <param name="row2">Row coordinate of the lower right corner point.</param>
		/// <param name="column2">Column coordinate of the lower right corner point.</param>
		// Token: 0x060016E1 RID: 5857 RVA: 0x000931C4 File Offset: 0x000913C4
		public void InnerRectangle1(out int row1, out int column1, out int row2, out int column2)
		{
			IntPtr proc = HalconAPI.PreCall(1734);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadI(proc, 0, num, out row1);
			num = HalconAPI.LoadI(proc, 1, num, out column1);
			num = HalconAPI.LoadI(proc, 2, num, out row2);
			num = HalconAPI.LoadI(proc, 3, num, out column2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Largest inner circle of a region.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="row">Line index of the center.</param>
		/// <param name="column">Column index of the center.</param>
		/// <param name="radius">Radius of the inner circle.</param>
		// Token: 0x060016E2 RID: 5858 RVA: 0x00093244 File Offset: 0x00091444
		public void InnerCircle(out HTuple row, out HTuple column, out HTuple radius)
		{
			IntPtr proc = HalconAPI.PreCall(1735);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out radius);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Largest inner circle of a region.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="row">Line index of the center.</param>
		/// <param name="column">Column index of the center.</param>
		/// <param name="radius">Radius of the inner circle.</param>
		// Token: 0x060016E3 RID: 5859 RVA: 0x000932B4 File Offset: 0x000914B4
		public void InnerCircle(out double row, out double column, out double radius)
		{
			IntPtr proc = HalconAPI.PreCall(1735);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out row);
			num = HalconAPI.LoadD(proc, 1, num, out column);
			num = HalconAPI.LoadD(proc, 2, num, out radius);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Calculate gray value moments and approximation by a first order surface (plane).
		///   Instance represents: Regions to be checked.
		/// </summary>
		/// <param name="image">Corresponding gray values.</param>
		/// <param name="algorithm">Algorithm for the fitting. Default: "regression"</param>
		/// <param name="iterations">Maximum number of iterations (unused for 'regression'). Default: 5</param>
		/// <param name="clippingFactor">Clipping factor for the elimination of outliers. Default: 2.0</param>
		/// <param name="beta">Parameter Beta of the approximating surface.</param>
		/// <param name="gamma">Parameter Gamma of the approximating surface.</param>
		/// <returns>Parameter Alpha of the approximating surface.</returns>
		// Token: 0x060016E4 RID: 5860 RVA: 0x00093320 File Offset: 0x00091520
		public HTuple FitSurfaceFirstOrder(HImage image, string algorithm, int iterations, double clippingFactor, out HTuple beta, out HTuple gamma)
		{
			IntPtr proc = HalconAPI.PreCall(1743);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.StoreS(proc, 0, algorithm);
			HalconAPI.StoreI(proc, 1, iterations);
			HalconAPI.StoreD(proc, 2, clippingFactor);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out beta);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out gamma);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Calculate gray value moments and approximation by a first order surface (plane).
		///   Instance represents: Regions to be checked.
		/// </summary>
		/// <param name="image">Corresponding gray values.</param>
		/// <param name="algorithm">Algorithm for the fitting. Default: "regression"</param>
		/// <param name="iterations">Maximum number of iterations (unused for 'regression'). Default: 5</param>
		/// <param name="clippingFactor">Clipping factor for the elimination of outliers. Default: 2.0</param>
		/// <param name="beta">Parameter Beta of the approximating surface.</param>
		/// <param name="gamma">Parameter Gamma of the approximating surface.</param>
		/// <returns>Parameter Alpha of the approximating surface.</returns>
		// Token: 0x060016E5 RID: 5861 RVA: 0x000933B8 File Offset: 0x000915B8
		public double FitSurfaceFirstOrder(HImage image, string algorithm, int iterations, double clippingFactor, out double beta, out double gamma)
		{
			IntPtr proc = HalconAPI.PreCall(1743);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.StoreS(proc, 0, algorithm);
			HalconAPI.StoreI(proc, 1, iterations);
			HalconAPI.StoreD(proc, 2, clippingFactor);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out beta);
			num = HalconAPI.LoadD(proc, 2, num, out gamma);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Calculate gray value moments and approximation by a second order surface.
		///   Instance represents: Regions to be checked.
		/// </summary>
		/// <param name="image">Corresponding gray values.</param>
		/// <param name="algorithm">Algorithm for the fitting. Default: "regression"</param>
		/// <param name="iterations">Maximum number of iterations (unused for 'regression'). Default: 5</param>
		/// <param name="clippingFactor">Clipping factor for the elimination of outliers. Default: 2.0</param>
		/// <param name="beta">Parameter Beta of the approximating surface.</param>
		/// <param name="gamma">Parameter Gamma of the approximating surface.</param>
		/// <param name="delta">Parameter Delta of the approximating surface.</param>
		/// <param name="epsilon">Parameter Epsilon of the approximating surface.</param>
		/// <param name="zeta">Parameter Zeta of the approximating surface.</param>
		/// <returns>Parameter Alpha of the approximating surface.</returns>
		// Token: 0x060016E6 RID: 5862 RVA: 0x00093450 File Offset: 0x00091650
		public HTuple FitSurfaceSecondOrder(HImage image, string algorithm, int iterations, double clippingFactor, out HTuple beta, out HTuple gamma, out HTuple delta, out HTuple epsilon, out HTuple zeta)
		{
			IntPtr proc = HalconAPI.PreCall(1744);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.StoreS(proc, 0, algorithm);
			HalconAPI.StoreI(proc, 1, iterations);
			HalconAPI.StoreD(proc, 2, clippingFactor);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out beta);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out gamma);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out delta);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out epsilon);
			num = HTuple.LoadNew(proc, 5, HTupleType.DOUBLE, num, out zeta);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Calculate gray value moments and approximation by a second order surface.
		///   Instance represents: Regions to be checked.
		/// </summary>
		/// <param name="image">Corresponding gray values.</param>
		/// <param name="algorithm">Algorithm for the fitting. Default: "regression"</param>
		/// <param name="iterations">Maximum number of iterations (unused for 'regression'). Default: 5</param>
		/// <param name="clippingFactor">Clipping factor for the elimination of outliers. Default: 2.0</param>
		/// <param name="beta">Parameter Beta of the approximating surface.</param>
		/// <param name="gamma">Parameter Gamma of the approximating surface.</param>
		/// <param name="delta">Parameter Delta of the approximating surface.</param>
		/// <param name="epsilon">Parameter Epsilon of the approximating surface.</param>
		/// <param name="zeta">Parameter Zeta of the approximating surface.</param>
		/// <returns>Parameter Alpha of the approximating surface.</returns>
		// Token: 0x060016E7 RID: 5863 RVA: 0x00093524 File Offset: 0x00091724
		public double FitSurfaceSecondOrder(HImage image, string algorithm, int iterations, double clippingFactor, out double beta, out double gamma, out double delta, out double epsilon, out double zeta)
		{
			IntPtr proc = HalconAPI.PreCall(1744);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.StoreS(proc, 0, algorithm);
			HalconAPI.StoreI(proc, 1, iterations);
			HalconAPI.StoreD(proc, 2, clippingFactor);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out beta);
			num = HalconAPI.LoadD(proc, 2, num, out gamma);
			num = HalconAPI.LoadD(proc, 3, num, out delta);
			num = HalconAPI.LoadD(proc, 4, num, out epsilon);
			num = HalconAPI.LoadD(proc, 5, num, out zeta);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Determine a histogram of features along all threshold values.
		///   Instance represents: Region in which the features are to be examined.
		/// </summary>
		/// <param name="image">Gray value image.</param>
		/// <param name="feature">Feature to be examined. Default: "convexity"</param>
		/// <param name="row">Row of the pixel which the region must contain. Default: 256</param>
		/// <param name="column">Column of the pixel which the region must contain. Default: 256</param>
		/// <param name="relativeHisto">Relative distribution of the feature.</param>
		/// <returns>Absolute distribution of the feature.</returns>
		// Token: 0x060016E8 RID: 5864 RVA: 0x000935F4 File Offset: 0x000917F4
		public HTuple ShapeHistoPoint(HImage image, string feature, int row, int column, out HTuple relativeHisto)
		{
			IntPtr proc = HalconAPI.PreCall(1747);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.StoreS(proc, 0, feature);
			HalconAPI.StoreI(proc, 1, row);
			HalconAPI.StoreI(proc, 2, column);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out relativeHisto);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Determine a histogram of features along all threshold values.
		///   Instance represents: Region in which the features are to be examined.
		/// </summary>
		/// <param name="image">Gray value image.</param>
		/// <param name="feature">Feature to be examined. Default: "connected_components"</param>
		/// <param name="relativeHisto">Relative distribution of the feature.</param>
		/// <returns>Absolute distribution of the feature.</returns>
		// Token: 0x060016E9 RID: 5865 RVA: 0x00093678 File Offset: 0x00091878
		public HTuple ShapeHistoAll(HImage image, string feature, out HTuple relativeHisto)
		{
			IntPtr proc = HalconAPI.PreCall(1748);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.StoreS(proc, 0, feature);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out relativeHisto);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Calculates gray value features for a set of regions.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="image">Gray value image.</param>
		/// <param name="features">Names of the features. Default: "mean"</param>
		/// <returns>Value sof the features.</returns>
		// Token: 0x060016EA RID: 5866 RVA: 0x000936EC File Offset: 0x000918EC
		public HTuple GrayFeatures(HImage image, HTuple features)
		{
			IntPtr proc = HalconAPI.PreCall(1749);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, features);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(features);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Calculates gray value features for a set of regions.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="image">Gray value image.</param>
		/// <param name="features">Names of the features. Default: "mean"</param>
		/// <returns>Value sof the features.</returns>
		// Token: 0x060016EB RID: 5867 RVA: 0x00093754 File Offset: 0x00091954
		public double GrayFeatures(HImage image, string features)
		{
			IntPtr proc = HalconAPI.PreCall(1749);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.StoreS(proc, 0, features);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Select regions based on gray value features.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="image">Gray value image.</param>
		/// <param name="features">Names of the features. Default: "mean"</param>
		/// <param name="operation">Logical connection of features. Default: "and"</param>
		/// <param name="min">Lower limit(s) of features or 'min'. Default: 128.0</param>
		/// <param name="max">Upper limit(s) of features or 'max'. Default: 255.0</param>
		/// <returns>Regions having features within the limits.</returns>
		// Token: 0x060016EC RID: 5868 RVA: 0x000937B4 File Offset: 0x000919B4
		public HRegion SelectGray(HImage image, HTuple features, string operation, HTuple min, HTuple max)
		{
			IntPtr proc = HalconAPI.PreCall(1750);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, features);
			HalconAPI.StoreS(proc, 1, operation);
			HalconAPI.Store(proc, 2, min);
			HalconAPI.Store(proc, 3, max);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(features);
			HalconAPI.UnpinTuple(min);
			HalconAPI.UnpinTuple(max);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Select regions based on gray value features.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="image">Gray value image.</param>
		/// <param name="features">Names of the features. Default: "mean"</param>
		/// <param name="operation">Logical connection of features. Default: "and"</param>
		/// <param name="min">Lower limit(s) of features or 'min'. Default: 128.0</param>
		/// <param name="max">Upper limit(s) of features or 'max'. Default: 255.0</param>
		/// <returns>Regions having features within the limits.</returns>
		// Token: 0x060016ED RID: 5869 RVA: 0x00093840 File Offset: 0x00091A40
		public HRegion SelectGray(HImage image, string features, string operation, double min, double max)
		{
			IntPtr proc = HalconAPI.PreCall(1750);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.StoreS(proc, 0, features);
			HalconAPI.StoreS(proc, 1, operation);
			HalconAPI.StoreD(proc, 2, min);
			HalconAPI.StoreD(proc, 3, max);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Determine the minimum and maximum gray values within regions.
		///   Instance represents: Regions, the features of which are to be calculated.
		/// </summary>
		/// <param name="image">Gray value image.</param>
		/// <param name="percent">Percentage below (above) the absolute maximum (minimum). Default: 0</param>
		/// <param name="min">"Minimum" gray value.</param>
		/// <param name="max">"Maximum" gray value.</param>
		/// <param name="range">Difference between Max and Min.</param>
		// Token: 0x060016EE RID: 5870 RVA: 0x000938B8 File Offset: 0x00091AB8
		public void MinMaxGray(HImage image, HTuple percent, out HTuple min, out HTuple max, out HTuple range)
		{
			IntPtr proc = HalconAPI.PreCall(1751);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, percent);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(percent);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out min);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out max);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out range);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
		}

		/// <summary>
		///   Determine the minimum and maximum gray values within regions.
		///   Instance represents: Regions, the features of which are to be calculated.
		/// </summary>
		/// <param name="image">Gray value image.</param>
		/// <param name="percent">Percentage below (above) the absolute maximum (minimum). Default: 0</param>
		/// <param name="min">"Minimum" gray value.</param>
		/// <param name="max">"Maximum" gray value.</param>
		/// <param name="range">Difference between Max and Min.</param>
		// Token: 0x060016EF RID: 5871 RVA: 0x00093944 File Offset: 0x00091B44
		public void MinMaxGray(HImage image, double percent, out double min, out double max, out double range)
		{
			IntPtr proc = HalconAPI.PreCall(1751);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.StoreD(proc, 0, percent);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out min);
			num = HalconAPI.LoadD(proc, 1, num, out max);
			num = HalconAPI.LoadD(proc, 2, num, out range);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
		}

		/// <summary>
		///   Calculate the mean and deviation of gray values.
		///   Instance represents: Regions in which the features are calculated.
		/// </summary>
		/// <param name="image">Gray value image.</param>
		/// <param name="deviation">Deviation of gray values within a region.</param>
		/// <returns>Mean gray value of a region.</returns>
		// Token: 0x060016F0 RID: 5872 RVA: 0x000939C8 File Offset: 0x00091BC8
		public HTuple Intensity(HImage image, out HTuple deviation)
		{
			IntPtr proc = HalconAPI.PreCall(1752);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out deviation);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Calculate the mean and deviation of gray values.
		///   Instance represents: Regions in which the features are calculated.
		/// </summary>
		/// <param name="image">Gray value image.</param>
		/// <param name="deviation">Deviation of gray values within a region.</param>
		/// <returns>Mean gray value of a region.</returns>
		// Token: 0x060016F1 RID: 5873 RVA: 0x00093A34 File Offset: 0x00091C34
		public double Intensity(HImage image, out double deviation)
		{
			IntPtr proc = HalconAPI.PreCall(1752);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out deviation);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Calculate the gray value distribution of a single channel image within a certain gray value range.
		///   Instance represents: Region in which the histogram is to be calculated.
		/// </summary>
		/// <param name="image">Input image.</param>
		/// <param name="min">Minimum gray value. Default: 0</param>
		/// <param name="max">Maximum gray value. Default: 255</param>
		/// <param name="numBins">Number of bins. Default: 256</param>
		/// <param name="binSize">Bin size.</param>
		/// <returns>Histogram to be calculated.</returns>
		// Token: 0x060016F2 RID: 5874 RVA: 0x00093A9C File Offset: 0x00091C9C
		public HTuple GrayHistoRange(HImage image, HTuple min, HTuple max, int numBins, out double binSize)
		{
			IntPtr proc = HalconAPI.PreCall(1753);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, min);
			HalconAPI.Store(proc, 1, max);
			HalconAPI.StoreI(proc, 2, numBins);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(min);
			HalconAPI.UnpinTuple(max);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out binSize);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Calculate the gray value distribution of a single channel image within a certain gray value range.
		///   Instance represents: Region in which the histogram is to be calculated.
		/// </summary>
		/// <param name="image">Input image.</param>
		/// <param name="min">Minimum gray value. Default: 0</param>
		/// <param name="max">Maximum gray value. Default: 255</param>
		/// <param name="numBins">Number of bins. Default: 256</param>
		/// <param name="binSize">Bin size.</param>
		/// <returns>Histogram to be calculated.</returns>
		// Token: 0x060016F3 RID: 5875 RVA: 0x00093B2C File Offset: 0x00091D2C
		public int GrayHistoRange(HImage image, double min, double max, int numBins, out double binSize)
		{
			IntPtr proc = HalconAPI.PreCall(1753);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.StoreD(proc, 0, min);
			HalconAPI.StoreD(proc, 1, max);
			HalconAPI.StoreI(proc, 2, numBins);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out binSize);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Calculate the histogram of two-channel gray value images.
		///   Instance represents: Region in which the histogram is to be calculated.
		/// </summary>
		/// <param name="imageCol">Channel 1.</param>
		/// <param name="imageRow">Channel 2.</param>
		/// <returns>Histogram to be calculated.</returns>
		// Token: 0x060016F4 RID: 5876 RVA: 0x00093BB0 File Offset: 0x00091DB0
		public HImage Histo2dim(HImage imageCol, HImage imageRow)
		{
			IntPtr proc = HalconAPI.PreCall(1754);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, imageCol);
			HalconAPI.Store(proc, 3, imageRow);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(imageCol);
			GC.KeepAlive(imageRow);
			return result;
		}

		/// <summary>
		///   Calculate the gray value distribution.
		///   Instance represents: Region in which the histogram is to be calculated.
		/// </summary>
		/// <param name="image">Image the gray value distribution of which is to be calculated.</param>
		/// <param name="quantization">Quantization of the gray values. Default: 1.0</param>
		/// <returns>Absolute frequencies of the gray values.</returns>
		// Token: 0x060016F5 RID: 5877 RVA: 0x00093C14 File Offset: 0x00091E14
		public HTuple GrayHistoAbs(HImage image, HTuple quantization)
		{
			IntPtr proc = HalconAPI.PreCall(1755);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, quantization);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(quantization);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Calculate the gray value distribution.
		///   Instance represents: Region in which the histogram is to be calculated.
		/// </summary>
		/// <param name="image">Image the gray value distribution of which is to be calculated.</param>
		/// <param name="quantization">Quantization of the gray values. Default: 1.0</param>
		/// <returns>Absolute frequencies of the gray values.</returns>
		// Token: 0x060016F6 RID: 5878 RVA: 0x00093C7C File Offset: 0x00091E7C
		public HTuple GrayHistoAbs(HImage image, double quantization)
		{
			IntPtr proc = HalconAPI.PreCall(1755);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.StoreD(proc, 0, quantization);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Calculate the gray value distribution.
		///   Instance represents: Region in which the histogram is to be calculated.
		/// </summary>
		/// <param name="image">Image the gray value distribution of which is to be calculated.</param>
		/// <param name="relativeHisto">Frequencies, normalized to the area of the region.</param>
		/// <returns>Absolute frequencies of the gray values.</returns>
		// Token: 0x060016F7 RID: 5879 RVA: 0x00093CDC File Offset: 0x00091EDC
		public HTuple GrayHisto(HImage image, out HTuple relativeHisto)
		{
			IntPtr proc = HalconAPI.PreCall(1756);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out relativeHisto);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Determine the entropy and anisotropy of images.
		///   Instance represents: Regions where the features are to be determined.
		/// </summary>
		/// <param name="image">Gray value image.</param>
		/// <param name="anisotropy">Measure of the symmetry of gray value distribution.</param>
		/// <returns>Information content (entropy) of the gray values.</returns>
		// Token: 0x060016F8 RID: 5880 RVA: 0x00093D48 File Offset: 0x00091F48
		public HTuple EntropyGray(HImage image, out HTuple anisotropy)
		{
			IntPtr proc = HalconAPI.PreCall(1757);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out anisotropy);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Determine the entropy and anisotropy of images.
		///   Instance represents: Regions where the features are to be determined.
		/// </summary>
		/// <param name="image">Gray value image.</param>
		/// <param name="anisotropy">Measure of the symmetry of gray value distribution.</param>
		/// <returns>Information content (entropy) of the gray values.</returns>
		// Token: 0x060016F9 RID: 5881 RVA: 0x00093DB4 File Offset: 0x00091FB4
		public double EntropyGray(HImage image, out double anisotropy)
		{
			IntPtr proc = HalconAPI.PreCall(1757);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out anisotropy);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Calculate a co-occurrence matrix and derive gray value features thereof.
		///   Instance represents: Region to be examined.
		/// </summary>
		/// <param name="image">Corresponding gray values.</param>
		/// <param name="ldGray">Number of gray values to be distinguished (2^LdGray@f$2^{LdGray}$). Default: 6</param>
		/// <param name="direction">Direction in which the matrix is to be calculated. Default: 0</param>
		/// <param name="correlation">Correlation of gray values.</param>
		/// <param name="homogeneity">Local homogeneity of gray values.</param>
		/// <param name="contrast">Gray value contrast.</param>
		/// <returns>Gray value energy.</returns>
		// Token: 0x060016FA RID: 5882 RVA: 0x00093E1C File Offset: 0x0009201C
		public HTuple CoocFeatureImage(HImage image, int ldGray, HTuple direction, out HTuple correlation, out HTuple homogeneity, out HTuple contrast)
		{
			IntPtr proc = HalconAPI.PreCall(1759);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.StoreI(proc, 0, ldGray);
			HalconAPI.Store(proc, 1, direction);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(direction);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out correlation);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out homogeneity);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out contrast);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Calculate a co-occurrence matrix and derive gray value features thereof.
		///   Instance represents: Region to be examined.
		/// </summary>
		/// <param name="image">Corresponding gray values.</param>
		/// <param name="ldGray">Number of gray values to be distinguished (2^LdGray@f$2^{LdGray}$). Default: 6</param>
		/// <param name="direction">Direction in which the matrix is to be calculated. Default: 0</param>
		/// <param name="correlation">Correlation of gray values.</param>
		/// <param name="homogeneity">Local homogeneity of gray values.</param>
		/// <param name="contrast">Gray value contrast.</param>
		/// <returns>Gray value energy.</returns>
		// Token: 0x060016FB RID: 5883 RVA: 0x00093EC8 File Offset: 0x000920C8
		public double CoocFeatureImage(HImage image, int ldGray, int direction, out double correlation, out double homogeneity, out double contrast)
		{
			IntPtr proc = HalconAPI.PreCall(1759);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.StoreI(proc, 0, ldGray);
			HalconAPI.StoreI(proc, 1, direction);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out correlation);
			num = HalconAPI.LoadD(proc, 2, num, out homogeneity);
			num = HalconAPI.LoadD(proc, 3, num, out contrast);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Calculate the co-occurrence matrix of a region in an image.
		///   Instance represents: Region to be checked.
		/// </summary>
		/// <param name="image">Image providing the gray values.</param>
		/// <param name="ldGray">Number of gray values to be distinguished (2^LdGray@f$2^{LdGray}$). Default: 6</param>
		/// <param name="direction">Direction of neighbor relation. Default: 0</param>
		/// <returns>Co-occurrence matrix (matrices).</returns>
		// Token: 0x060016FC RID: 5884 RVA: 0x00093F68 File Offset: 0x00092168
		public HImage GenCoocMatrix(HImage image, int ldGray, int direction)
		{
			IntPtr proc = HalconAPI.PreCall(1760);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.StoreI(proc, 0, ldGray);
			HalconAPI.StoreI(proc, 1, direction);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Calculate gray value moments and approximation by a plane.
		///   Instance represents: Regions to be checked.
		/// </summary>
		/// <param name="image">Corresponding gray values.</param>
		/// <param name="MRow">Mixed moments along a line.</param>
		/// <param name="MCol">Mixed moments along a column.</param>
		/// <param name="alpha">Parameter Alpha of the approximating plane.</param>
		/// <param name="beta">Parameter Beta of the approximating plane.</param>
		/// <param name="mean">Mean gray value.</param>
		// Token: 0x060016FD RID: 5885 RVA: 0x00093FD0 File Offset: 0x000921D0
		public void MomentsGrayPlane(HImage image, out HTuple MRow, out HTuple MCol, out HTuple alpha, out HTuple beta, out HTuple mean)
		{
			IntPtr proc = HalconAPI.PreCall(1761);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out MRow);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out MCol);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out alpha);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out beta);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out mean);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
		}

		/// <summary>
		///   Calculate gray value moments and approximation by a plane.
		///   Instance represents: Regions to be checked.
		/// </summary>
		/// <param name="image">Corresponding gray values.</param>
		/// <param name="MRow">Mixed moments along a line.</param>
		/// <param name="MCol">Mixed moments along a column.</param>
		/// <param name="alpha">Parameter Alpha of the approximating plane.</param>
		/// <param name="beta">Parameter Beta of the approximating plane.</param>
		/// <param name="mean">Mean gray value.</param>
		// Token: 0x060016FE RID: 5886 RVA: 0x00094074 File Offset: 0x00092274
		public void MomentsGrayPlane(HImage image, out double MRow, out double MCol, out double alpha, out double beta, out double mean)
		{
			IntPtr proc = HalconAPI.PreCall(1761);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out MRow);
			num = HalconAPI.LoadD(proc, 1, num, out MCol);
			num = HalconAPI.LoadD(proc, 2, num, out alpha);
			num = HalconAPI.LoadD(proc, 3, num, out beta);
			num = HalconAPI.LoadD(proc, 4, num, out mean);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
		}

		/// <summary>
		///   Calculate the deviation of the gray values from the approximating image plane.
		///   Instance represents: Regions, of which the plane deviation is to be calculated.
		/// </summary>
		/// <param name="image">Gray value image.</param>
		/// <returns>Deviation of the gray values within a region.</returns>
		// Token: 0x060016FF RID: 5887 RVA: 0x00094114 File Offset: 0x00092314
		public HTuple PlaneDeviation(HImage image)
		{
			IntPtr proc = HalconAPI.PreCall(1762);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Compute the orientation and major axes of a region in a gray value image.
		///   Instance represents: Region(s) to be examined.
		/// </summary>
		/// <param name="image">Gray value image.</param>
		/// <param name="rb">Minor axis of the region.</param>
		/// <param name="phi">Angle enclosed by the major axis and the x-axis.</param>
		/// <returns>Major axis of the region.</returns>
		// Token: 0x06001700 RID: 5888 RVA: 0x0009416C File Offset: 0x0009236C
		public HTuple EllipticAxisGray(HImage image, out HTuple rb, out HTuple phi)
		{
			IntPtr proc = HalconAPI.PreCall(1763);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out rb);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out phi);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Compute the orientation and major axes of a region in a gray value image.
		///   Instance represents: Region(s) to be examined.
		/// </summary>
		/// <param name="image">Gray value image.</param>
		/// <param name="rb">Minor axis of the region.</param>
		/// <param name="phi">Angle enclosed by the major axis and the x-axis.</param>
		/// <returns>Major axis of the region.</returns>
		// Token: 0x06001701 RID: 5889 RVA: 0x000941EC File Offset: 0x000923EC
		public double EllipticAxisGray(HImage image, out double rb, out double phi)
		{
			IntPtr proc = HalconAPI.PreCall(1763);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out rb);
			num = HalconAPI.LoadD(proc, 2, num, out phi);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Compute the area and center of gravity of a region in a gray value image.
		///   Instance represents: Region(s) to be examined.
		/// </summary>
		/// <param name="image">Gray value image.</param>
		/// <param name="row">Row coordinate of the gray value center of gravity.</param>
		/// <param name="column">Column coordinate of the gray value center of gravity.</param>
		/// <returns>Gray value volume of the region.</returns>
		// Token: 0x06001702 RID: 5890 RVA: 0x00094268 File Offset: 0x00092468
		public HTuple AreaCenterGray(HImage image, out HTuple row, out HTuple column)
		{
			IntPtr proc = HalconAPI.PreCall(1764);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out column);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Compute the area and center of gravity of a region in a gray value image.
		///   Instance represents: Region(s) to be examined.
		/// </summary>
		/// <param name="image">Gray value image.</param>
		/// <param name="row">Row coordinate of the gray value center of gravity.</param>
		/// <param name="column">Column coordinate of the gray value center of gravity.</param>
		/// <returns>Gray value volume of the region.</returns>
		// Token: 0x06001703 RID: 5891 RVA: 0x000942E8 File Offset: 0x000924E8
		public double AreaCenterGray(HImage image, out double row, out double column)
		{
			IntPtr proc = HalconAPI.PreCall(1764);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out row);
			num = HalconAPI.LoadD(proc, 2, num, out column);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Calculate horizontal and vertical gray-value projections.
		///   Instance represents: Region to be processed.
		/// </summary>
		/// <param name="image">Grayvalues for projections.</param>
		/// <param name="mode">Method to compute the projections. Default: "simple"</param>
		/// <param name="vertProjection">Vertical projection.</param>
		/// <returns>Horizontal projection.</returns>
		// Token: 0x06001704 RID: 5892 RVA: 0x00094364 File Offset: 0x00092564
		public HTuple GrayProjections(HImage image, string mode, out HTuple vertProjection)
		{
			IntPtr proc = HalconAPI.PreCall(1765);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.StoreS(proc, 0, mode);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out vertProjection);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Asynchronous grab of images and preprocessed image data from the specified image acquisition device.
		///   Modified instance represents: Pre-processed image regions.
		/// </summary>
		/// <param name="contours">Pre-processed XLD contours.</param>
		/// <param name="acqHandle">Handle of the acquisition device to be used.</param>
		/// <param name="maxDelay">Maximum tolerated delay between the start of the asynchronous grab and the delivery of the image [ms]. Default: -1.0</param>
		/// <param name="data">Pre-processed control data.</param>
		/// <returns>Grabbed image data.</returns>
		// Token: 0x06001705 RID: 5893 RVA: 0x000943D8 File Offset: 0x000925D8
		public HImage GrabDataAsync(out HXLDCont contours, HFramegrabber acqHandle, double maxDelay, out HTuple data)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(2029);
			HalconAPI.Store(proc, 0, acqHandle);
			HalconAPI.StoreD(proc, 1, maxDelay);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 2, num);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HXLDCont.LoadNew(proc, 3, num, out contours);
			num = HTuple.LoadNew(proc, 0, num, out data);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(acqHandle);
			return result;
		}

		/// <summary>
		///   Asynchronous grab of images and preprocessed image data from the specified image acquisition device.
		///   Modified instance represents: Pre-processed image regions.
		/// </summary>
		/// <param name="contours">Pre-processed XLD contours.</param>
		/// <param name="acqHandle">Handle of the acquisition device to be used.</param>
		/// <param name="maxDelay">Maximum tolerated delay between the start of the asynchronous grab and the delivery of the image [ms]. Default: -1.0</param>
		/// <param name="data">Pre-processed control data.</param>
		/// <returns>Grabbed image data.</returns>
		// Token: 0x06001706 RID: 5894 RVA: 0x0009446C File Offset: 0x0009266C
		public HImage GrabDataAsync(out HXLDCont contours, HFramegrabber acqHandle, double maxDelay, out string data)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(2029);
			HalconAPI.Store(proc, 0, acqHandle);
			HalconAPI.StoreD(proc, 1, maxDelay);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 2, num);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HXLDCont.LoadNew(proc, 3, num, out contours);
			num = HalconAPI.LoadS(proc, 0, num, out data);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(acqHandle);
			return result;
		}

		/// <summary>
		///   Synchronous grab of images and preprocessed image data from the specified image acquisition device.
		///   Modified instance represents: Preprocessed image regions.
		/// </summary>
		/// <param name="contours">Preprocessed XLD contours.</param>
		/// <param name="acqHandle">Handle of the acquisition device to be used.</param>
		/// <param name="data">Preprocessed control data.</param>
		/// <returns>Grabbed image data.</returns>
		// Token: 0x06001707 RID: 5895 RVA: 0x00094500 File Offset: 0x00092700
		public HImage GrabData(out HXLDCont contours, HFramegrabber acqHandle, out HTuple data)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(2030);
			HalconAPI.Store(proc, 0, acqHandle);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 2, num);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HXLDCont.LoadNew(proc, 3, num, out contours);
			num = HTuple.LoadNew(proc, 0, num, out data);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(acqHandle);
			return result;
		}

		/// <summary>
		///   Synchronous grab of images and preprocessed image data from the specified image acquisition device.
		///   Modified instance represents: Preprocessed image regions.
		/// </summary>
		/// <param name="contours">Preprocessed XLD contours.</param>
		/// <param name="acqHandle">Handle of the acquisition device to be used.</param>
		/// <param name="data">Preprocessed control data.</param>
		/// <returns>Grabbed image data.</returns>
		// Token: 0x06001708 RID: 5896 RVA: 0x0009458C File Offset: 0x0009278C
		public HImage GrabData(out HXLDCont contours, HFramegrabber acqHandle, out string data)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(2030);
			HalconAPI.Store(proc, 0, acqHandle);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 2, num);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HXLDCont.LoadNew(proc, 3, num, out contours);
			num = HalconAPI.LoadS(proc, 0, num, out data);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(acqHandle);
			return result;
		}

		/// <summary>
		///   Classify multiple characters with an CNN-based OCR classifier.
		///   Instance represents: Characters to be recognized.
		/// </summary>
		/// <param name="image">Gray values of the characters.</param>
		/// <param name="OCRHandle">Handle of the OCR classifier.</param>
		/// <param name="confidence">Confidence of the class of the characters.</param>
		/// <returns>Result of classifying the characters with the CNN.</returns>
		// Token: 0x06001709 RID: 5897 RVA: 0x00094618 File Offset: 0x00092818
		public HTuple DoOcrMultiClassCnn(HImage image, HOCRCnn OCRHandle, out HTuple confidence)
		{
			IntPtr proc = HalconAPI.PreCall(2056);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, OCRHandle);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out confidence);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			GC.KeepAlive(OCRHandle);
			return result;
		}

		/// <summary>
		///   Classify multiple characters with an CNN-based OCR classifier.
		///   Instance represents: Characters to be recognized.
		/// </summary>
		/// <param name="image">Gray values of the characters.</param>
		/// <param name="OCRHandle">Handle of the OCR classifier.</param>
		/// <param name="confidence">Confidence of the class of the characters.</param>
		/// <returns>Result of classifying the characters with the CNN.</returns>
		// Token: 0x0600170A RID: 5898 RVA: 0x00094690 File Offset: 0x00092890
		public string DoOcrMultiClassCnn(HImage image, HOCRCnn OCRHandle, out double confidence)
		{
			IntPtr proc = HalconAPI.PreCall(2056);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, OCRHandle);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out confidence);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			GC.KeepAlive(OCRHandle);
			return result;
		}

		/// <summary>
		///   Classify a single character with an CNN-based OCR classifier.
		///   Instance represents: Character to be recognized.
		/// </summary>
		/// <param name="image">Gray values of the character.</param>
		/// <param name="OCRHandle">Handle of the OCR classifier.</param>
		/// <param name="num">Number of best classes to determine. Default: 1</param>
		/// <param name="confidence">Confidence(s) of the class(es) of the character.</param>
		/// <returns>Result of classifying the character with the CNN.</returns>
		// Token: 0x0600170B RID: 5899 RVA: 0x00094708 File Offset: 0x00092908
		public HTuple DoOcrSingleClassCnn(HImage image, HOCRCnn OCRHandle, HTuple num, out HTuple confidence)
		{
			IntPtr proc = HalconAPI.PreCall(2057);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, OCRHandle);
			HalconAPI.Store(proc, 1, num);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num2 = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(num);
			HTuple result;
			num2 = HTuple.LoadNew(proc, 0, num2, out result);
			num2 = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num2, out confidence);
			HalconAPI.PostCall(proc, num2);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			GC.KeepAlive(OCRHandle);
			return result;
		}

		/// <summary>
		///   Classify a single character with an CNN-based OCR classifier.
		///   Instance represents: Character to be recognized.
		/// </summary>
		/// <param name="image">Gray values of the character.</param>
		/// <param name="OCRHandle">Handle of the OCR classifier.</param>
		/// <param name="num">Number of best classes to determine. Default: 1</param>
		/// <param name="confidence">Confidence(s) of the class(es) of the character.</param>
		/// <returns>Result of classifying the character with the CNN.</returns>
		// Token: 0x0600170C RID: 5900 RVA: 0x00094790 File Offset: 0x00092990
		public string DoOcrSingleClassCnn(HImage image, HOCRCnn OCRHandle, HTuple num, out double confidence)
		{
			IntPtr proc = HalconAPI.PreCall(2057);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, OCRHandle);
			HalconAPI.Store(proc, 1, num);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num2 = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(num);
			string result;
			num2 = HalconAPI.LoadS(proc, 0, num2, out result);
			num2 = HalconAPI.LoadD(proc, 1, num2, out confidence);
			HalconAPI.PostCall(proc, num2);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			GC.KeepAlive(OCRHandle);
			return result;
		}

		/// <summary>
		///   Classify a related group of characters with an CNN-based OCR classifier.
		///   Instance represents: Characters to be recognized.
		/// </summary>
		/// <param name="image">Gray values of the characters.</param>
		/// <param name="OCRHandle">Handle of the OCR classifier.</param>
		/// <param name="expression">Expression describing the allowed word structure.</param>
		/// <param name="numAlternatives">Number of classes per character considered for the internal word correction. Default: 3</param>
		/// <param name="numCorrections">Maximum number of corrected characters. Default: 2</param>
		/// <param name="confidence">Confidence of the class of the characters.</param>
		/// <param name="word">Word text after classification and correction.</param>
		/// <param name="score">Measure of similarity between corrected word and uncorrected classification results.</param>
		/// <returns>Result of classifying the characters with the CNN.</returns>
		// Token: 0x0600170D RID: 5901 RVA: 0x00094818 File Offset: 0x00092A18
		public HTuple DoOcrWordCnn(HImage image, HOCRCnn OCRHandle, string expression, int numAlternatives, int numCorrections, out HTuple confidence, out string word, out double score)
		{
			IntPtr proc = HalconAPI.PreCall(2058);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, OCRHandle);
			HalconAPI.StoreS(proc, 1, expression);
			HalconAPI.StoreI(proc, 2, numAlternatives);
			HalconAPI.StoreI(proc, 3, numCorrections);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out confidence);
			num = HalconAPI.LoadS(proc, 2, num, out word);
			num = HalconAPI.LoadD(proc, 3, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			GC.KeepAlive(OCRHandle);
			return result;
		}

		/// <summary>
		///   Classify a related group of characters with an CNN-based OCR classifier.
		///   Instance represents: Characters to be recognized.
		/// </summary>
		/// <param name="image">Gray values of the characters.</param>
		/// <param name="OCRHandle">Handle of the OCR classifier.</param>
		/// <param name="expression">Expression describing the allowed word structure.</param>
		/// <param name="numAlternatives">Number of classes per character considered for the internal word correction. Default: 3</param>
		/// <param name="numCorrections">Maximum number of corrected characters. Default: 2</param>
		/// <param name="confidence">Confidence of the class of the characters.</param>
		/// <param name="word">Word text after classification and correction.</param>
		/// <param name="score">Measure of similarity between corrected word and uncorrected classification results.</param>
		/// <returns>Result of classifying the characters with the CNN.</returns>
		// Token: 0x0600170E RID: 5902 RVA: 0x000948D0 File Offset: 0x00092AD0
		public string DoOcrWordCnn(HImage image, HOCRCnn OCRHandle, string expression, int numAlternatives, int numCorrections, out double confidence, out string word, out double score)
		{
			IntPtr proc = HalconAPI.PreCall(2058);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, OCRHandle);
			HalconAPI.StoreS(proc, 1, expression);
			HalconAPI.StoreI(proc, 2, numAlternatives);
			HalconAPI.StoreI(proc, 3, numCorrections);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out confidence);
			num = HalconAPI.LoadS(proc, 2, num, out word);
			num = HalconAPI.LoadD(proc, 3, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			GC.KeepAlive(OCRHandle);
			return result;
		}

		/// <summary>
		///   Compute the width, height, and aspect ratio of the surrounding rectangle parallel to the coordinate axes.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="width">Width of the surrounding rectangle of the region.</param>
		/// <param name="ratio">Aspect ratio of the surrounding rectangle of the region.</param>
		/// <returns>Height of the surrounding rectangle of the region.</returns>
		// Token: 0x0600170F RID: 5903 RVA: 0x00094988 File Offset: 0x00092B88
		public HTuple HeightWidthRatio(out HTuple width, out HTuple ratio)
		{
			IntPtr proc = HalconAPI.PreCall(2119);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out width);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out ratio);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the width, height, and aspect ratio of the surrounding rectangle parallel to the coordinate axes.
		///   Instance represents: Regions to be examined.
		/// </summary>
		/// <param name="width">Width of the surrounding rectangle of the region.</param>
		/// <param name="ratio">Aspect ratio of the surrounding rectangle of the region.</param>
		/// <returns>Height of the surrounding rectangle of the region.</returns>
		// Token: 0x06001710 RID: 5904 RVA: 0x000949F8 File Offset: 0x00092BF8
		public int HeightWidthRatio(out int width, out double ratio)
		{
			IntPtr proc = HalconAPI.PreCall(2119);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			num = HalconAPI.LoadI(proc, 1, num, out width);
			num = HalconAPI.LoadD(proc, 2, num, out ratio);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Insert objects into an iconic object tuple.
		///   Instance represents: Input object tuple.
		/// </summary>
		/// <param name="objectsInsert">Object tuple to insert.</param>
		/// <param name="index">Index to insert objects.</param>
		/// <returns>Extended object tuple.</returns>
		// Token: 0x06001711 RID: 5905 RVA: 0x00094A64 File Offset: 0x00092C64
		public HRegion InsertObj(HRegion objectsInsert, int index)
		{
			IntPtr proc = HalconAPI.PreCall(2121);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objectsInsert);
			HalconAPI.StoreI(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objectsInsert);
			return result;
		}

		/// <summary>
		///   Remove objects from an iconic object tuple.
		///   Instance represents: Input object tuple.
		/// </summary>
		/// <param name="index">Indices of the objects to be removed.</param>
		/// <returns>Remaining object tuple.</returns>
		// Token: 0x06001712 RID: 5906 RVA: 0x00094AC4 File Offset: 0x00092CC4
		public new HRegion RemoveObj(HTuple index)
		{
			IntPtr proc = HalconAPI.PreCall(2124);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(index);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Remove objects from an iconic object tuple.
		///   Instance represents: Input object tuple.
		/// </summary>
		/// <param name="index">Indices of the objects to be removed.</param>
		/// <returns>Remaining object tuple.</returns>
		// Token: 0x06001713 RID: 5907 RVA: 0x00094B1C File Offset: 0x00092D1C
		public new HRegion RemoveObj(int index)
		{
			IntPtr proc = HalconAPI.PreCall(2124);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Replaces one or more elements of an iconic object tuple.
		///   Instance represents: Iconic Input Object.
		/// </summary>
		/// <param name="objectsReplace">Element(s) to replace.</param>
		/// <param name="index">Index/Indices of elements to be replaced.</param>
		/// <returns>Tuple with replaced elements.</returns>
		// Token: 0x06001714 RID: 5908 RVA: 0x00094B6C File Offset: 0x00092D6C
		public HRegion ReplaceObj(HRegion objectsReplace, HTuple index)
		{
			IntPtr proc = HalconAPI.PreCall(2125);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objectsReplace);
			HalconAPI.Store(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(index);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objectsReplace);
			return result;
		}

		/// <summary>
		///   Replaces one or more elements of an iconic object tuple.
		///   Instance represents: Iconic Input Object.
		/// </summary>
		/// <param name="objectsReplace">Element(s) to replace.</param>
		/// <param name="index">Index/Indices of elements to be replaced.</param>
		/// <returns>Tuple with replaced elements.</returns>
		// Token: 0x06001715 RID: 5909 RVA: 0x00094BD0 File Offset: 0x00092DD0
		public HRegion ReplaceObj(HRegion objectsReplace, int index)
		{
			IntPtr proc = HalconAPI.PreCall(2125);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objectsReplace);
			HalconAPI.StoreI(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objectsReplace);
			return result;
		}
	}
}
